diff --git a/decompiled-wabt/Reproducer.md b/decompiled-wabt/Reproducer.md new file mode 100644 index 000000000..1d17a0131 --- /dev/null +++ b/decompiled-wabt/Reproducer.md @@ -0,0 +1,51 @@ +# JDK-8376400 reproducer + +This is a self contained reproducer for JDK-8376400. +We keep the pom.wml for conveninece, but it can be reproduced with plain `javac`/`java` executions. + +To build: `./build.sh` +To run: `./run.sh` + +On Java 18+, or on Java 17 after applying this commit: `f3eb5014aa75af4463308f52f2bc6e9fcd2da36c` the run command completes successfully. + +On Java <= 17 the run fails with this error(much down the line): + +``` +Exception in thread "main" com.dylibso.chicory.runtime.WasmRuntimeException: out of bounds memory access: attempted to access address: 668598272 but limit is: 668598272 and size: 8 + at com.dylibso.chicory.runtime.ByteBufferMemory.outOfBoundsException(ByteBufferMemory.java:313) + at com.dylibso.chicory.runtime.ByteBufferMemory.writeLong(ByteBufferMemory.java:424) + at com.dylibso.chicory.wabt.Wat2WasmMachine.func_1890(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call_1890(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.func_231(Wat2WasmMachine.java:22513) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call_231(Wat2WasmMachine.java:22523) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.func_224(Wat2WasmMachine.java:22138) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call_224(Wat2WasmMachine.java:22152) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.func_41(Wat2WasmMachine.java:2699) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call_41(Wat2WasmMachine.java:3555) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.func_40(Wat2WasmMachine.java:2488) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call_40(Wat2WasmMachine.java:2679) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.func_21(Wat2WasmMachine.java:678) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call_21(Wat2WasmMachine.java:998) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.func_33(Wat2WasmMachine.java:1758) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call_33(Wat2WasmMachine.java:1765) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.func_1791(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call_1791(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call(Wat2WasmMachine.java) + at com.dylibso.chicory.wabt.Wat2WasmMachine.func_18(Wat2WasmMachine.java:191) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call_18(Wat2WasmMachine.java:208) + at com.dylibso.chicory.wabt.Wat2WasmMachine.call(Wat2WasmMachine.java) + at com.dylibso.chicory.runtime.Instance$Exports.lambda$function$0(Instance.java:219) + at com.dylibso.chicory.runtime.Instance.initialize(Instance.java:184) + at com.dylibso.chicory.runtime.Instance.(Instance.java:118) + at com.dylibso.chicory.runtime.Instance$Builder.build(Instance.java:884) + at com.dylibso.chicory.wabt.Wat2Wasm.parse(Wat2Wasm.java:65) + at com.dylibso.chicory.wabt.Wat2Wasm.parse(Wat2Wasm.java:41) + at com.dylibso.chicory.wabt.Main.main(Main.java:8) +``` diff --git a/decompiled-wabt/build.sh b/decompiled-wabt/build.sh new file mode 100755 index 000000000..fa966cc8e --- /dev/null +++ b/decompiled-wabt/build.sh @@ -0,0 +1,16 @@ +#!/bin/bash +set -e + +DIR="$(cd "$(dirname "$0")" && pwd)" +OUT="$DIR/target/classes" + +rm -rf "$OUT" +mkdir -p "$OUT" + +javac \ + -d "$OUT" \ + $(find "$DIR/src/main/java" -name '*.java') + +cp -r "$DIR/src/main/resources/"* "$OUT/" + +echo "Build complete: $OUT" diff --git a/decompiled-wabt/pom.xml b/decompiled-wabt/pom.xml new file mode 100644 index 000000000..fed0b16a7 --- /dev/null +++ b/decompiled-wabt/pom.xml @@ -0,0 +1,71 @@ + + + 4.0.0 + com.dylibso.chicory + + wabt + 999-SNAPSHOT + jar + + Chicory - wabt + wabt tools compiled to pure Java with Chicory + + + 11 + + + + + com.dylibso.chicory + annotations + 1.6.1 + provided + + + org.junit.jupiter + junit-jupiter + 5.11.4 + test + + + + + + + + org.apache.maven.plugins + maven-shade-plugin + + + + shade + + package + + false + + + com.dylibso.chicory.wabt.Main + + + + + + + + + diff --git a/decompiled-wabt/run.sh b/decompiled-wabt/run.sh new file mode 100755 index 000000000..5f3656eca --- /dev/null +++ b/decompiled-wabt/run.sh @@ -0,0 +1,7 @@ +#!/bin/bash +set -e + +DIR="$(cd "$(dirname "$0")" && pwd)" +OUT="$DIR/target/classes" + +java -cp "$OUT" com.dylibso.chicory.wabt.Main "$@" diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/log/BasicLogger.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/log/BasicLogger.java new file mode 100644 index 000000000..218def11f --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/log/BasicLogger.java @@ -0,0 +1,37 @@ +package com.dylibso.chicory.log; + +public class BasicLogger implements Logger { + private static final java.util.logging.Logger LOGGER = + java.util.logging.Logger.getLogger("chicory"); + + @Override + public void log(Level level, String msg, Throwable throwable) { + LOGGER.log(toJavaLoggerLevel(level), msg, throwable); + } + + @Override + public boolean isLoggable(Level level) { + return LOGGER.isLoggable(toJavaLoggerLevel(level)); + } + + java.util.logging.Level toJavaLoggerLevel(Logger.Level level) { + switch (level) { + case ALL: + return java.util.logging.Level.ALL; + case TRACE: + return java.util.logging.Level.FINEST; + case DEBUG: + return java.util.logging.Level.FINE; + case INFO: + return java.util.logging.Level.INFO; + case WARNING: + return java.util.logging.Level.WARNING; + case ERROR: + return java.util.logging.Level.SEVERE; + case OFF: + return java.util.logging.Level.OFF; + default: + throw new IllegalArgumentException("Unsupported logger level: " + level); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/log/Logger.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/log/Logger.java new file mode 100644 index 000000000..f65488e9c --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/log/Logger.java @@ -0,0 +1,253 @@ +package com.dylibso.chicory.log; + +import java.util.Objects; +import java.util.function.Supplier; + +// +// for convenience, we are inspired by java.lang.System:Logger.Level +// +public interface Logger { + enum Level { + ALL(Integer.MIN_VALUE), + TRACE(400), + DEBUG(500), + INFO(800), + WARNING(900), + ERROR(1000), + OFF(Integer.MAX_VALUE); + + private final int severity; + + Level(int severity) { + this.severity = severity; + } + + /** + * Returns the name of this level. + * + * @return this level {@linkplain #name()}. + */ + public final String getName() { + return name(); + } + + /** + * Returns the severity of this level. + * A higher severity means a more severe condition. + * + * @return this level severity. + */ + public final int getSeverity() { + return severity; + } + } + + void log(Level level, String msg, Throwable throwable); + + boolean isLoggable(Level level); + + // + // TRACE + // + + default void trace(String msg) { + Objects.requireNonNull(msg); + + if (isLoggable(Level.TRACE)) { + log(Level.TRACE, msg, null); + } + } + + default void trace(Supplier msgSupplier) { + Objects.requireNonNull(msgSupplier); + + if (isLoggable(Level.TRACE)) { + log(Level.TRACE, msgSupplier.get(), null); + } + } + + default void trace(Supplier msgSupplier, Throwable throwable) { + Objects.requireNonNull(msgSupplier); + + if (isLoggable(Level.TRACE)) { + log(Level.TRACE, msgSupplier.get(), throwable); + } + } + + default void tracef(String format, Object... args) { + Objects.requireNonNull(format); + + if (isLoggable(Level.TRACE)) { + String msg = format; + if (args.length != 0) { + msg = String.format(msg, args); + } + + log(Level.TRACE, msg, null); + } + } + + // + // DEBUG + // + + default void debug(String msg) { + Objects.requireNonNull(msg); + + if (isLoggable(Level.DEBUG)) { + log(Level.DEBUG, msg, null); + } + } + + default void debug(Supplier msgSupplier) { + Objects.requireNonNull(msgSupplier); + + if (isLoggable(Level.DEBUG)) { + log(Level.DEBUG, msgSupplier.get(), null); + } + } + + default void debug(Supplier msgSupplier, Throwable throwable) { + Objects.requireNonNull(msgSupplier); + + if (isLoggable(Level.DEBUG)) { + log(Level.DEBUG, msgSupplier.get(), throwable); + } + } + + default void debugf(String format, Object... args) { + Objects.requireNonNull(format); + + if (isLoggable(Level.DEBUG)) { + String msg = format; + if (args.length != 0) { + msg = String.format(msg, args); + } + + log(Level.DEBUG, msg, null); + } + } + + // + // INFO + // + + default void info(String msg) { + Objects.requireNonNull(msg); + + if (isLoggable(Level.INFO)) { + log(Level.INFO, msg, null); + } + } + + default void info(Supplier msgSupplier) { + Objects.requireNonNull(msgSupplier); + + if (isLoggable(Level.INFO)) { + log(Level.INFO, msgSupplier.get(), null); + } + } + + default void info(Supplier msgSupplier, Throwable throwable) { + Objects.requireNonNull(msgSupplier); + + if (isLoggable(Level.INFO)) { + log(Level.INFO, msgSupplier.get(), throwable); + } + } + + default void infof(String format, Object... args) { + Objects.requireNonNull(format); + + if (isLoggable(Level.INFO)) { + String msg = format; + if (args.length != 0) { + msg = String.format(msg, args); + } + + log(Level.INFO, msg, null); + } + } + + // + // WARNING + // + + default void warn(String msg) { + Objects.requireNonNull(msg); + + if (isLoggable(Level.WARNING)) { + log(Level.WARNING, msg, null); + } + } + + default void warn(Supplier msgSupplier) { + Objects.requireNonNull(msgSupplier); + + if (isLoggable(Level.WARNING)) { + log(Level.WARNING, msgSupplier.get(), null); + } + } + + default void warn(Supplier msgSupplier, Throwable throwable) { + Objects.requireNonNull(msgSupplier); + + if (isLoggable(Level.WARNING)) { + log(Level.WARNING, msgSupplier.get(), throwable); + } + } + + default void warnf(String format, Object... args) { + Objects.requireNonNull(format); + + if (isLoggable(Level.WARNING)) { + String msg = format; + if (args.length != 0) { + msg = String.format(msg, args); + } + + log(Level.WARNING, msg, null); + } + } + + // + // ERROR + // + + default void error(String msg) { + Objects.requireNonNull(msg); + + if (isLoggable(Level.ERROR)) { + log(Level.ERROR, msg, null); + } + } + + default void error(Supplier msgSupplier) { + Objects.requireNonNull(msgSupplier); + + if (isLoggable(Level.ERROR)) { + log(Level.ERROR, msgSupplier.get(), null); + } + } + + default void error(Supplier msgSupplier, Throwable throwable) { + Objects.requireNonNull(msgSupplier); + + if (isLoggable(Level.ERROR)) { + log(Level.ERROR, msgSupplier.get(), throwable); + } + } + + default void errorf(String format, Object... args) { + Objects.requireNonNull(format); + + if (isLoggable(Level.ERROR)) { + String msg = format; + if (args.length != 0) { + msg = String.format(msg, args); + } + + log(Level.ERROR, msg, null); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/log/SystemLogger.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/log/SystemLogger.java new file mode 100644 index 000000000..c47a511e1 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/log/SystemLogger.java @@ -0,0 +1,38 @@ +package com.dylibso.chicory.log; + +public class SystemLogger implements Logger { + private static final System.Logger LOGGER = System.getLogger("chicory"); + + @Override + public void log(Level level, String msg, Throwable throwable) { + System.Logger.Level sll = toSystemLoggerLevel(level); + + LOGGER.log(sll, msg, throwable); + } + + @Override + public boolean isLoggable(Level level) { + System.Logger.Level sll = toSystemLoggerLevel(level); + + return LOGGER.isLoggable(sll); + } + + System.Logger.Level toSystemLoggerLevel(Logger.Level level) { + switch (level) { + case ALL: + return System.Logger.Level.ALL; + case TRACE: + return System.Logger.Level.TRACE; + case DEBUG: + return System.Logger.Level.DEBUG; + case INFO: + return System.Logger.Level.INFO; + case WARNING: + return System.Logger.Level.WARNING; + case ERROR: + return System.Logger.Level.ERROR; + default: + throw new IllegalArgumentException("Unsupported logger level: " + level); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/BitOps.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/BitOps.java new file mode 100644 index 000000000..588efb680 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/BitOps.java @@ -0,0 +1,9 @@ +package com.dylibso.chicory.runtime; + +public final class BitOps { + + public static final int TRUE = 1; + public static final int FALSE = 0; + + private BitOps() {} +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ByteArrayMemory.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ByteArrayMemory.java new file mode 100644 index 000000000..3a112c046 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ByteArrayMemory.java @@ -0,0 +1,1308 @@ +package com.dylibso.chicory.runtime; + +import static com.dylibso.chicory.runtime.ConstantEvaluators.computeConstantValue; +import static java.lang.Math.min; + +import com.dylibso.chicory.runtime.alloc.MemAllocStrategy; +import com.dylibso.chicory.wasm.ChicoryException; +import com.dylibso.chicory.wasm.UninstantiableException; +import com.dylibso.chicory.wasm.types.ActiveDataSegment; +import com.dylibso.chicory.wasm.types.DataSegment; +import com.dylibso.chicory.wasm.types.MemoryLimits; +import com.dylibso.chicory.wasm.types.PassiveDataSegment; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.VarHandle; +import java.lang.invoke.VarHandle.AccessMode; +import java.nio.ByteOrder; +import java.util.Arrays; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.BooleanSupplier; +import java.util.function.Function; + +/** + * Represents the linear memory in the Wasm program. Can be shared + * reference b/w the host and the guest. + * + * try-catch is faster than explicit checks and can be optimized by the JVM. + * Catching generic RuntimeException to keep the method bodies short and easily inlinable. + */ +public final class ByteArrayMemory implements Memory { + // get access to the byte array elements viewed as if it were + // a different primitive array type, such as int[], long[], etc. + // This is actually the fastest way to access and reinterpret the underlying bytes. + // see: https://stackoverflow.com/a/65276765/7898052 + private static final VarHandle BYTE_ARR_HANDLE = + MethodHandles.arrayElementVarHandle(byte[].class); + private static final VarHandle SHORT_ARR_HANDLE = + MethodHandles.byteArrayViewVarHandle(short[].class, ByteOrder.LITTLE_ENDIAN); + private static final VarHandle INT_ARR_HANDLE = + MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN); + private static final VarHandle FLOAT_ARR_HANDLE = + MethodHandles.byteArrayViewVarHandle(float[].class, ByteOrder.LITTLE_ENDIAN); + private static final VarHandle LONG_ARR_HANDLE = + MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN); + private static final VarHandle DOUBLE_ARR_HANDLE = + MethodHandles.byteArrayViewVarHandle(double[].class, ByteOrder.LITTLE_ENDIAN); + + private static final boolean HAS_BYTE_ATOMICS = hasFullAtomicSupport(BYTE_ARR_HANDLE); + private static final boolean HAS_SHORT_ATOMICS = hasFullAtomicSupport(SHORT_ARR_HANDLE); + private static final boolean HAS_INT_ATOMICS = hasFullAtomicSupport(INT_ARR_HANDLE); + private static final boolean HAS_LONG_ATOMICS = hasFullAtomicSupport(LONG_ARR_HANDLE); + + // Page addressing constants + private static final int PAGE_SHIFT = 16; // PAGE_SIZE = 65536 = 2^16 + private static final int PAGE_MASK = PAGE_SIZE - 1; + + private static boolean hasFullAtomicSupport(VarHandle varHandle) { + return varHandle.isAccessModeSupported(AccessMode.GET_VOLATILE) + && varHandle.isAccessModeSupported(AccessMode.SET_VOLATILE) + && varHandle.isAccessModeSupported(AccessMode.COMPARE_AND_EXCHANGE) + && varHandle.isAccessModeSupported(AccessMode.GET_AND_SET) + && varHandle.isAccessModeSupported(AccessMode.GET_AND_ADD) + && varHandle.isAccessModeSupported(AccessMode.GET_AND_BITWISE_AND) + && varHandle.isAccessModeSupported(AccessMode.GET_AND_BITWISE_OR) + && varHandle.isAccessModeSupported(AccessMode.GET_AND_BITWISE_XOR); + } + + private final MemoryLimits limits; + private DataSegment[] dataSegments; + + // Page-based storage: fixed-size array of pages, slots filled lazily during grow + // Individual pages are never reallocated once created, enabling lock-free reads + private final byte[][] pages; + + // Number of currently allocated pages + private volatile int nPages; + + // Lock for grow operation (only used when memory is shared) + private final Object growLock = new Object(); + + public ByteArrayMemory(MemoryLimits limits) { + this.limits = limits; + int maxPages = min(limits.maximumPages(), RUNTIME_MAX_PAGES); + this.pages = new byte[maxPages][]; + + // Allocate initial pages + for (int i = 0; i < limits.initialPages(); i++) { + pages[i] = new byte[PAGE_SIZE]; + } + this.nPages = limits.initialPages(); + + if (limits.shared()) { + waitStates = new ConcurrentHashMap<>(); + } else { + waitStates = null; + } + } + + /** + * @deprecated The MemAllocStrategy is no longer used since memory is allocated by page. + * Use {@link #ByteArrayMemory(MemoryLimits)} instead. + */ + @Deprecated + @SuppressWarnings("InlineMeSuggester") + public ByteArrayMemory(MemoryLimits limits, MemAllocStrategy allocStrategy) { + this(limits); + } + + // Tracks wait state per address: waiter count and pending wakeups + // all field access should be guarded by synchronizing on the instance. + // Invariants: 0 <= pendingWakeups <= waiterCount + private static final class WaitState { + // The number of threads currently waiting + int waiterCount; + // The number of waiting threads that have been scheduled to wake up + int pendingWakeups; + } + + private final Map waitStates; + + @Override + @SuppressWarnings("removal") + public Object lock(int address) { + throw new UnsupportedOperationException(); + } + + private Object monitor(int address) { + return waitStates.computeIfAbsent(address, k -> new WaitState()); + } + + // Wait IF condition is true + private int waitOn(int address, BooleanSupplier condition, long timeout) { + if (!shared()) { + throw new ChicoryException("Attempt to wait on a non-shared memory, not supported."); + } + + long deadline = (timeout < 0) ? Long.MAX_VALUE : System.nanoTime() + timeout; + + WaitState state = waitStates.computeIfAbsent(address, k -> new WaitState()); + + synchronized (state) { + // Check the condition while holding the lock + // This must be atomic with the decision to wait + if (!condition.getAsBoolean()) { + return 1; // not-equal + } + + state.waiterCount++; + try { + + while (state.pendingWakeups == 0) { + long remaining = deadline - System.nanoTime(); + if (remaining <= 0) { + return 2; // timeout + } + long millis = Math.max(remaining / 1_000_000L, 0); + int nanos = Math.max((int) (remaining % 1_000_000L), 0); + try { + state.wait(millis, nanos); + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + throw new ChicoryInterruptedException("Thread interrupted"); + } + } + return 0; // woken + } finally { + + if (state.pendingWakeups > 0) { + // any thread leaving the try block is correct to consume + // a pending wakeup IF available: + // ret 0 - woken thread correctly consumes a wakeup + // ret 2 - timeout can only occur with pendingWakeups == 0 so will not consume + // throw - isn't part of the wasm runtime but is semantically correct to consume + state.pendingWakeups--; + } + state.waiterCount--; + assert (0 <= state.pendingWakeups); + assert (state.pendingWakeups <= state.waiterCount); + } + } + } + + @Override + @SuppressWarnings("removal") + public int waitOn(int address, int expected, long timeout) { + return waitOn(address, () -> atomicReadInt(address) == expected, timeout); + } + + @Override + @SuppressWarnings("removal") + public int waitOn(int address, long expected, long timeout) { + return waitOn(address, () -> atomicReadLong(address) == expected, timeout); + } + + // Notify waiters at this address + @Override + @SuppressWarnings("removal") + public int notify(int address, int maxThreads) { + if (!shared()) { + return 0; + } + + WaitState state = waitStates.get(address); + if (state == null) { + return 0; + } + + synchronized (state) { + int actualWaiters = state.waiterCount - state.pendingWakeups; + + if (actualWaiters == 0) { + return 0; + } + + // Calculate how many to wake: min(actualWaiters, maxThreads) + int toWake; + if (maxThreads < 0) { + toWake = actualWaiters; // wake all + } else { + toWake = Math.min(actualWaiters, maxThreads); + } + + // Add pending wakeups - waiters will consume these + state.pendingWakeups += toWake; + assert (state.pendingWakeups <= state.waiterCount); + + // It's always safe to notify all. In the wait routine we consume pendingWakeups + // and go back to waiting if there are none. We could also choose to notify waiters + // one by one in a loop. The optimal choice of whether to notify all should be + // toWake > C * state.waiterCount, where C is an unknown constant weighing the cost + // of looping through notify vs. having threads wake and go back to waiting. Since + // the constant is unknown we opt for the simplest choice of just notifying all. + state.notifyAll(); + + return toWake; + } + } + + /** + * Gets the size of the memory in number of pages + */ + @Override + public int pages() { + return nPages; + } + + @Override + public int grow(int size) { + if (!shared()) { + return growImpl(size); + } + synchronized (growLock) { + return growImpl(size); + } + } + + private int growImpl(int size) { + int prevPages = nPages; + int numPages = prevPages + size; + + if (numPages > maximumPages() || numPages < prevPages) { + return -1; + } + + // Allocate new pages + for (int i = prevPages; i < numPages; i++) { + pages[i] = new byte[PAGE_SIZE]; + } + + // Publish new page count (volatile write ensures visibility of new pages) + nPages = numPages; + return prevPages; + } + + @Override + public int initialPages() { + return this.limits.initialPages(); + } + + @Override + public int maximumPages() { + return min(this.limits.maximumPages(), RUNTIME_MAX_PAGES); + } + + @Override + public boolean shared() { + return this.limits.shared(); + } + + @Override + public void initialize(Instance instance, DataSegment[] dataSegments) { + this.dataSegments = dataSegments; + if (dataSegments == null) { + return; + } + + for (var s : dataSegments) { + if (s instanceof ActiveDataSegment) { + var segment = (ActiveDataSegment) s; + var offsetExpr = segment.offsetInstructions(); + var data = segment.data(); + var offset = (int) computeConstantValue(instance, offsetExpr)[0]; + checkBounds(offset, data.length, sizeInBytes(), UninstantiableException::new); + write(offset, data, 0, data.length); + } else if (s instanceof PassiveDataSegment) { + // Passive segment should be skipped + } else { + throw new ChicoryException("Data segment should be active or passive: " + s); + } + } + } + + private static void checkBounds( + int addr, int size, int limit, Function exceptionFactory) { + if (addr < 0 || size < 0 || addr > limit || (size > 0 && ((addr + size) > limit))) { + var errorMsg = + "out of bounds memory access: attempted to access address: " + + addr + + " but limit is: " + + limit + + " and size: " + + size; + throw exceptionFactory.apply(errorMsg); + } + } + + private RuntimeException outOfBoundsException(RuntimeException e, int addr, int size) { + if (e instanceof IndexOutOfBoundsException + || e instanceof IllegalArgumentException + || e instanceof NullPointerException + || e instanceof NegativeArraySizeException) { + var limit = sizeInBytes(); + var errorMsg = + "out of bounds memory access: attempted to access address: " + + addr + + " but limit is: " + + limit + + " and size: " + + size; + return new WasmRuntimeException(errorMsg); + } else { + return e; + } + } + + @Override + public void initPassiveSegment(int segmentId, int dest, int offset, int size) { + var segment = dataSegments[segmentId]; + write(dest, segment.data(), offset, size); + } + + private int sizeInBytes() { + return PAGE_SIZE * nPages; + } + + @Override + public void write(int addr, byte[] data, int offset, int size) { + checkBounds(offset, size, data.length, WasmRuntimeException::new); + checkBounds(addr, size, sizeInBytes(), WasmRuntimeException::new); + while (size > 0) { + int pageIdx = addr >>> PAGE_SHIFT; + int pageOffset = addr & PAGE_MASK; + int chunk = Math.min(size, PAGE_SIZE - pageOffset); + System.arraycopy(data, offset, pages[pageIdx], pageOffset, chunk); + addr += chunk; + offset += chunk; + size -= chunk; + } + } + + @Override + public byte read(int addr) { + try { + return pages[addr >>> PAGE_SHIFT][addr & PAGE_MASK]; + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public byte[] readBytes(int addr, int len) { + checkBounds(addr, len, sizeInBytes(), WasmRuntimeException::new); + byte[] result = new byte[len]; + int destOffset = 0; + int remaining = len; + int a = addr; + while (remaining > 0) { + int pageIdx = a >>> PAGE_SHIFT; + int pageOffset = a & PAGE_MASK; + int chunk = Math.min(remaining, PAGE_SIZE - pageOffset); + System.arraycopy(pages[pageIdx], pageOffset, result, destOffset, chunk); + a += chunk; + destOffset += chunk; + remaining -= chunk; + } + return result; + } + + @Override + public void writeI32(int addr, int data) { + int off = addr & PAGE_MASK; + if (off + 4 <= PAGE_SIZE) { + try { + INT_ARR_HANDLE.set(pages[addr >>> PAGE_SHIFT], off, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } else { + writeI32Slow(addr, data); + } + } + + private void writeI32Slow(int addr, int data) { + checkBounds(addr, 4, sizeInBytes(), WasmRuntimeException::new); + writeByte(addr, (byte) data); + writeByte(addr + 1, (byte) (data >>> 8)); + writeByte(addr + 2, (byte) (data >>> 16)); + writeByte(addr + 3, (byte) (data >>> 24)); + } + + @Override + public int readInt(int addr) { + int off = addr & PAGE_MASK; + if (off + 4 <= PAGE_SIZE) { + try { + return (int) INT_ARR_HANDLE.get(pages[addr >>> PAGE_SHIFT], off); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } else { + return readIntSlow(addr); + } + } + + private int readIntSlow(int addr) { + return (read(addr) & 0xFF) + | ((read(addr + 1) & 0xFF) << 8) + | ((read(addr + 2) & 0xFF) << 16) + | ((read(addr + 3) & 0xFF) << 24); + } + + @Override + public void writeLong(int addr, long data) { + int off = addr & PAGE_MASK; + if (off + 8 <= PAGE_SIZE) { + try { + LONG_ARR_HANDLE.set(pages[addr >>> PAGE_SHIFT], off, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } else { + writeLongSlow(addr, data); + } + } + + private void writeLongSlow(int addr, long data) { + checkBounds(addr, 8, sizeInBytes(), WasmRuntimeException::new); + writeByte(addr, (byte) data); + writeByte(addr + 1, (byte) (data >>> 8)); + writeByte(addr + 2, (byte) (data >>> 16)); + writeByte(addr + 3, (byte) (data >>> 24)); + writeByte(addr + 4, (byte) (data >>> 32)); + writeByte(addr + 5, (byte) (data >>> 40)); + writeByte(addr + 6, (byte) (data >>> 48)); + writeByte(addr + 7, (byte) (data >>> 56)); + } + + @Override + public long readLong(int addr) { + int off = addr & PAGE_MASK; + if (off + 8 <= PAGE_SIZE) { + try { + return (long) LONG_ARR_HANDLE.get(pages[addr >>> PAGE_SHIFT], off); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } else { + return readLongSlow(addr); + } + } + + private long readLongSlow(int addr) { + return (read(addr) & 0xFFL) + | ((read(addr + 1) & 0xFFL) << 8) + | ((read(addr + 2) & 0xFFL) << 16) + | ((read(addr + 3) & 0xFFL) << 24) + | ((read(addr + 4) & 0xFFL) << 32) + | ((read(addr + 5) & 0xFFL) << 40) + | ((read(addr + 6) & 0xFFL) << 48) + | ((read(addr + 7) & 0xFFL) << 56); + } + + @Override + public void writeShort(int addr, short data) { + int off = addr & PAGE_MASK; + if (off + 2 <= PAGE_SIZE) { + try { + SHORT_ARR_HANDLE.set(pages[addr >>> PAGE_SHIFT], off, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } else { + writeShortSlow(addr, data); + } + } + + private void writeShortSlow(int addr, short data) { + checkBounds(addr, 2, sizeInBytes(), WasmRuntimeException::new); + writeByte(addr, (byte) data); + writeByte(addr + 1, (byte) (data >>> 8)); + } + + @Override + public short readShort(int addr) { + int off = addr & PAGE_MASK; + if (off + 2 <= PAGE_SIZE) { + try { + return (short) SHORT_ARR_HANDLE.get(pages[addr >>> PAGE_SHIFT], off); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } else { + return readShortSlow(addr); + } + } + + private short readShortSlow(int addr) { + return (short) ((read(addr) & 0xFF) | ((read(addr + 1) & 0xFF) << 8)); + } + + @Override + public long readU16(int addr) { + return readShort(addr) & 0xFFFFL; + } + + @Override + public void writeByte(int addr, byte data) { + try { + pages[addr >>> PAGE_SHIFT][addr & PAGE_MASK] = data; + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public void writeF32(int addr, float data) { + int off = addr & PAGE_MASK; + if (off + 4 <= PAGE_SIZE) { + try { + FLOAT_ARR_HANDLE.set(pages[addr >>> PAGE_SHIFT], off, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } else { + writeI32(addr, Float.floatToRawIntBits(data)); + } + } + + @Override + public long readF32(int addr) { + return readInt(addr); + } + + @Override + public float readFloat(int addr) { + int off = addr & PAGE_MASK; + if (off + 4 <= PAGE_SIZE) { + try { + return (float) FLOAT_ARR_HANDLE.get(pages[addr >>> PAGE_SHIFT], off); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } else { + return Float.intBitsToFloat(readInt(addr)); + } + } + + @Override + public void writeF64(int addr, double data) { + int off = addr & PAGE_MASK; + if (off + 8 <= PAGE_SIZE) { + try { + DOUBLE_ARR_HANDLE.set(pages[addr >>> PAGE_SHIFT], off, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } else { + writeLong(addr, Double.doubleToRawLongBits(data)); + } + } + + @Override + public double readDouble(int addr) { + int off = addr & PAGE_MASK; + if (off + 8 <= PAGE_SIZE) { + try { + return (double) DOUBLE_ARR_HANDLE.get(pages[addr >>> PAGE_SHIFT], off); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } else { + return Double.longBitsToDouble(readLong(addr)); + } + } + + @Override + public long readF64(int addr) { + return readLong(addr); + } + + @Override + public void zero() { + fill((byte) 0, 0, sizeInBytes()); + } + + @Override + public void fill(byte value, int fromIndex, int toIndex) { + int addr = fromIndex; + int remaining = toIndex - fromIndex; + checkBounds(addr, remaining, sizeInBytes(), WasmRuntimeException::new); + while (remaining > 0) { + int pageIdx = addr >>> PAGE_SHIFT; + int pageOffset = addr & PAGE_MASK; + int chunk = Math.min(remaining, PAGE_SIZE - pageOffset); + Arrays.fill(pages[pageIdx], pageOffset, pageOffset + chunk, value); + addr += chunk; + remaining -= chunk; + } + } + + @Override + public void copy(int dest, int src, int size) { + int limit = sizeInBytes(); + checkBounds(dest, size, limit, WasmRuntimeException::new); + checkBounds(src, size, limit, WasmRuntimeException::new); + while (size > 0) { + int destOffset = dest & PAGE_MASK; + int srcOffset = src & PAGE_MASK; + int chunk = Math.min(size, PAGE_SIZE - Math.max(destOffset, srcOffset)); + System.arraycopy( + pages[src >>> PAGE_SHIFT], + srcOffset, + pages[dest >>> PAGE_SHIFT], + destOffset, + chunk); + dest += chunk; + src += chunk; + size -= chunk; + } + } + + @Override + public void drop(int segment) { + dataSegments[segment] = PassiveDataSegment.EMPTY; + } + + // =========================================== + // Atomic operations + // =========================================== + + @Override + public void atomicFence() { + VarHandle.fullFence(); + } + + @Override + public byte atomicAddByte(int addr, byte delta) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_BYTE_ATOMICS) { + return (byte) BYTE_ARR_HANDLE.getAndAdd(page, off, delta); + } + synchronized (monitor(addr)) { + byte value = (byte) BYTE_ARR_HANDLE.get(page, off); + BYTE_ARR_HANDLE.set(page, off, (byte) (value + delta)); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public int atomicAddInt(int addr, int delta) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_INT_ATOMICS) { + return (int) INT_ARR_HANDLE.getAndAdd(page, off, delta); + } + synchronized (monitor(addr)) { + int value = (int) INT_ARR_HANDLE.get(page, off); + INT_ARR_HANDLE.set(page, off, value + delta); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } + + @Override + public long atomicAddLong(int addr, long delta) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_LONG_ATOMICS) { + return (long) LONG_ARR_HANDLE.getAndAdd(page, off, delta); + } + synchronized (monitor(addr)) { + long value = (long) LONG_ARR_HANDLE.get(page, off); + LONG_ARR_HANDLE.set(page, off, value + delta); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } + + @Override + public short atomicAddShort(int addr, short delta) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_SHORT_ATOMICS) { + return (short) SHORT_ARR_HANDLE.getAndAdd(page, off, delta); + } + if (HAS_INT_ATOMICS) { + // cas loop using aligned int + int alignedOff = off & ~3; + int shift = (off & 2) * 8; + int mask = 0xFFFF << shift; + + while (true) { + int oldInt = (int) INT_ARR_HANDLE.getVolatile(page, alignedOff); + short oldShort = (short) ((oldInt >>> shift) & 0xFFFF); + short newShort = (short) (oldShort + delta); + int newInt = (oldInt & ~mask) | ((newShort & 0xFFFF) << shift); + if (INT_ARR_HANDLE.compareAndSet(page, alignedOff, oldInt, newInt)) { + return oldShort; + } + } + } + synchronized (monitor(addr)) { + short value = (short) SHORT_ARR_HANDLE.get(page, off); + SHORT_ARR_HANDLE.set(page, off, (short) (value + delta)); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } + + @Override + public byte atomicAndByte(int addr, byte mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_BYTE_ATOMICS) { + return (byte) BYTE_ARR_HANDLE.getAndBitwiseAnd(page, off, mask); + } + synchronized (monitor(addr)) { + byte value = (byte) BYTE_ARR_HANDLE.get(page, off); + BYTE_ARR_HANDLE.set(page, off, (byte) (value & mask)); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public int atomicAndInt(int addr, int mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_INT_ATOMICS) { + return (int) INT_ARR_HANDLE.getAndBitwiseAnd(page, off, mask); + } + synchronized (monitor(addr)) { + int value = (int) INT_ARR_HANDLE.get(page, off); + INT_ARR_HANDLE.set(page, off, value & mask); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } + + @Override + public long atomicAndLong(int addr, long mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_LONG_ATOMICS) { + return (long) LONG_ARR_HANDLE.getAndBitwiseAnd(page, off, mask); + } + synchronized (monitor(addr)) { + long value = (long) LONG_ARR_HANDLE.get(page, off); + LONG_ARR_HANDLE.set(page, off, value & mask); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } + + @Override + public short atomicAndShort(int addr, short mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_SHORT_ATOMICS) { + return (short) SHORT_ARR_HANDLE.getAndBitwiseAnd(page, off, mask); + } + if (HAS_INT_ATOMICS) { + // leverage that 0xFFFF is identity for and + int alignedOff = off & ~3; + int shift = (off & 2) * 8; + int intMask = ((mask & 0xFFFF) << shift) | ~(0xFFFF << shift); + int intValue = (int) INT_ARR_HANDLE.getAndBitwiseAnd(page, alignedOff, intMask); + return (short) ((intValue >>> shift) & 0xFFFF); + } + synchronized (monitor(addr)) { + short value = (short) SHORT_ARR_HANDLE.get(page, off); + SHORT_ARR_HANDLE.set(page, off, (short) (value & mask)); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } + + @Override + public byte atomicCmpxchgByte(int addr, byte expected, byte replacement) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_BYTE_ATOMICS) { + return (byte) BYTE_ARR_HANDLE.compareAndExchange(page, off, expected, replacement); + } + synchronized (monitor(addr)) { + byte value = (byte) BYTE_ARR_HANDLE.get(page, off); + if (value == expected) { + BYTE_ARR_HANDLE.set(page, off, replacement); + } + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public int atomicCmpxchgInt(int addr, int expected, int replacement) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_INT_ATOMICS) { + return (int) INT_ARR_HANDLE.compareAndExchange(page, off, expected, replacement); + } + synchronized (monitor(addr)) { + int value = (int) INT_ARR_HANDLE.get(page, off); + if (value == expected) { + INT_ARR_HANDLE.set(page, off, replacement); + } + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } + + @Override + public long atomicCmpxchgLong(int addr, long expected, long replacement) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_LONG_ATOMICS) { + return (long) LONG_ARR_HANDLE.compareAndExchange(page, off, expected, replacement); + } + synchronized (monitor(addr)) { + long value = (long) LONG_ARR_HANDLE.get(page, off); + if (value == expected) { + LONG_ARR_HANDLE.set(page, off, replacement); + } + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } + + @Override + public short atomicCmpxchgShort(int addr, short expected, short replacement) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_SHORT_ATOMICS) { + return (short) + SHORT_ARR_HANDLE.compareAndExchange(page, off, expected, replacement); + } + if (HAS_INT_ATOMICS) { + int alignedOff = off & ~3; + int shift = (off & 2) * 8; + int mask = 0xFFFF << shift; + + while (true) { + int oldInt = (int) INT_ARR_HANDLE.getVolatile(page, alignedOff); + short oldShort = (short) ((oldInt >>> shift) & 0xFFFF); + if (oldShort != expected) { + return oldShort; // no match, return current value without swapping + } + int newInt = (oldInt & ~mask) | ((replacement & 0xFFFF) << shift); + if (INT_ARR_HANDLE.compareAndSet(page, alignedOff, oldInt, newInt)) { + return oldShort; + } + } + } + synchronized (monitor(addr)) { + short value = (short) SHORT_ARR_HANDLE.get(page, off); + if (value == expected) { + SHORT_ARR_HANDLE.set(page, off, replacement); + } + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } + + @Override + public byte atomicOrByte(int addr, byte mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_BYTE_ATOMICS) { + return (byte) BYTE_ARR_HANDLE.getAndBitwiseOr(page, off, mask); + } + synchronized (monitor(addr)) { + byte value = (byte) BYTE_ARR_HANDLE.get(page, off); + BYTE_ARR_HANDLE.set(page, off, (byte) (value | mask)); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public int atomicOrInt(int addr, int mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_INT_ATOMICS) { + return (int) INT_ARR_HANDLE.getAndBitwiseOr(page, off, mask); + } + synchronized (monitor(addr)) { + int value = (int) INT_ARR_HANDLE.get(page, off); + INT_ARR_HANDLE.set(page, off, value | mask); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } + + @Override + public long atomicOrLong(int addr, long mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_LONG_ATOMICS) { + return (long) LONG_ARR_HANDLE.getAndBitwiseOr(page, off, mask); + } + synchronized (monitor(addr)) { + long value = (long) LONG_ARR_HANDLE.get(page, off); + LONG_ARR_HANDLE.set(page, off, value | mask); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } + + @Override + public short atomicOrShort(int addr, short mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_SHORT_ATOMICS) { + return (short) SHORT_ARR_HANDLE.getAndBitwiseOr(page, off, mask); + } + if (HAS_INT_ATOMICS) { + // leverage that 0x0000 is identity for or + int alignedOff = off & ~3; + int shift = (off & 2) * 8; + int intMask = ((mask & 0xFFFF) << shift); + int intValue = (int) INT_ARR_HANDLE.getAndBitwiseOr(page, alignedOff, intMask); + return (short) ((intValue >>> shift) & 0xFFFF); + } + synchronized (monitor(addr)) { + short value = (short) SHORT_ARR_HANDLE.get(page, off); + SHORT_ARR_HANDLE.set(page, off, (short) (value | mask)); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } + + @Override + public byte atomicReadByte(int addr) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (BYTE_ARR_HANDLE.isAccessModeSupported(AccessMode.GET_VOLATILE)) { + return (byte) BYTE_ARR_HANDLE.getVolatile(page, off); + } + synchronized (monitor(addr)) { + return (byte) BYTE_ARR_HANDLE.get(page, off); + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public int atomicReadInt(int addr) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (INT_ARR_HANDLE.isAccessModeSupported(AccessMode.GET_VOLATILE)) { + return (int) INT_ARR_HANDLE.getVolatile(page, off); + } + synchronized (monitor(addr)) { + return (int) INT_ARR_HANDLE.get(page, off); + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } + + @Override + public long atomicReadLong(int addr) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (LONG_ARR_HANDLE.isAccessModeSupported(AccessMode.GET_VOLATILE)) { + return (long) LONG_ARR_HANDLE.getVolatile(page, off); + } + synchronized (monitor(addr)) { + return (long) LONG_ARR_HANDLE.get(page, off); + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } + + @Override + public short atomicReadShort(int addr) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (SHORT_ARR_HANDLE.isAccessModeSupported(AccessMode.GET_VOLATILE)) { + return (short) SHORT_ARR_HANDLE.getVolatile(page, off); + } + synchronized (monitor(addr)) { + return (short) SHORT_ARR_HANDLE.get(page, off); + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } + + @Override + public void atomicWriteByte(int addr, byte value) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (BYTE_ARR_HANDLE.isAccessModeSupported(AccessMode.SET_VOLATILE)) { + BYTE_ARR_HANDLE.setVolatile(page, off, value); + return; + } + synchronized (monitor(addr)) { + BYTE_ARR_HANDLE.set(page, off, value); + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public void atomicWriteInt(int addr, int value) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (INT_ARR_HANDLE.isAccessModeSupported(AccessMode.SET_VOLATILE)) { + INT_ARR_HANDLE.setVolatile(page, off, value); + return; + } + synchronized (monitor(addr)) { + INT_ARR_HANDLE.set(page, off, value); + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } + + @Override + public void atomicWriteLong(int addr, long value) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (LONG_ARR_HANDLE.isAccessModeSupported(AccessMode.SET_VOLATILE)) { + LONG_ARR_HANDLE.setVolatile(page, off, value); + return; + } + synchronized (monitor(addr)) { + LONG_ARR_HANDLE.set(page, off, value); + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } + + @Override + public void atomicWriteShort(int addr, short value) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (SHORT_ARR_HANDLE.isAccessModeSupported(AccessMode.SET_VOLATILE)) { + SHORT_ARR_HANDLE.setVolatile(page, off, value); + return; + } + synchronized (monitor(addr)) { + SHORT_ARR_HANDLE.set(page, off, value); + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } + + @Override + public byte atomicXchgByte(int addr, byte value) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_BYTE_ATOMICS) { + return (byte) BYTE_ARR_HANDLE.getAndSet(page, off, value); + } + synchronized (monitor(addr)) { + byte oldValue = (byte) BYTE_ARR_HANDLE.get(page, off); + BYTE_ARR_HANDLE.set(page, off, value); + return oldValue; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public int atomicXchgInt(int addr, int value) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_INT_ATOMICS) { + return (int) INT_ARR_HANDLE.getAndSet(page, off, value); + } + synchronized (monitor(addr)) { + int oldValue = (int) INT_ARR_HANDLE.get(page, off); + INT_ARR_HANDLE.set(page, off, value); + return oldValue; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } + + @Override + public long atomicXchgLong(int addr, long value) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_LONG_ATOMICS) { + return (long) LONG_ARR_HANDLE.getAndSet(page, off, value); + } + synchronized (monitor(addr)) { + long oldValue = (long) LONG_ARR_HANDLE.get(page, off); + LONG_ARR_HANDLE.set(page, off, value); + return oldValue; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } + + @Override + public short atomicXchgShort(int addr, short value) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_SHORT_ATOMICS) { + return (short) SHORT_ARR_HANDLE.getAndSet(page, off, value); + } + if (HAS_INT_ATOMICS) { + int alignedOff = off & ~3; + int shift = (off & 2) * 8; + int mask = 0xFFFF << shift; + + while (true) { + int oldInt = (int) INT_ARR_HANDLE.getVolatile(page, alignedOff); + int newInt = (oldInt & ~mask) | ((value & 0xFFFF) << shift); + if (INT_ARR_HANDLE.compareAndSet(page, alignedOff, oldInt, newInt)) { + return (short) ((oldInt >>> shift) & 0xFFFF); + } + } + } + synchronized (monitor(addr)) { + short oldValue = (short) SHORT_ARR_HANDLE.get(page, off); + SHORT_ARR_HANDLE.set(page, off, value); + return oldValue; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } + + @Override + public byte atomicXorByte(int addr, byte mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_BYTE_ATOMICS) { + return (byte) BYTE_ARR_HANDLE.getAndBitwiseXor(page, off, mask); + } + synchronized (monitor(addr)) { + byte value = (byte) BYTE_ARR_HANDLE.get(page, off); + BYTE_ARR_HANDLE.set(page, off, (byte) (value ^ mask)); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public int atomicXorInt(int addr, int mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_INT_ATOMICS) { + return (int) INT_ARR_HANDLE.getAndBitwiseXor(page, off, mask); + } + synchronized (monitor(addr)) { + int value = (int) INT_ARR_HANDLE.get(page, off); + INT_ARR_HANDLE.set(page, off, value ^ mask); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } + + @Override + public long atomicXorLong(int addr, long mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_LONG_ATOMICS) { + return (long) LONG_ARR_HANDLE.getAndBitwiseXor(page, off, mask); + } + synchronized (monitor(addr)) { + long value = (long) LONG_ARR_HANDLE.get(page, off); + LONG_ARR_HANDLE.set(page, off, value ^ mask); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } + + @Override + public short atomicXorShort(int addr, short mask) { + try { + byte[] page = pages[addr >>> PAGE_SHIFT]; + int off = addr & PAGE_MASK; + if (HAS_SHORT_ATOMICS) { + return (short) SHORT_ARR_HANDLE.getAndBitwiseXor(page, off, mask); + } + if (HAS_INT_ATOMICS) { + // leverage that 0x0000 is identity for xor + int alignedOff = off & ~3; + int shift = (off & 2) * 8; + int intMask = ((mask & 0xFFFF) << shift); + int intValue = (int) INT_ARR_HANDLE.getAndBitwiseXor(page, alignedOff, intMask); + return (short) ((intValue >>> shift) & 0xFFFF); + } + synchronized (monitor(addr)) { + short value = (short) SHORT_ARR_HANDLE.get(page, off); + SHORT_ARR_HANDLE.set(page, off, (short) (value ^ mask)); + return value; + } + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ByteBufferMemory.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ByteBufferMemory.java new file mode 100644 index 000000000..10d1b0b8e --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ByteBufferMemory.java @@ -0,0 +1,642 @@ +package com.dylibso.chicory.runtime; + +import static com.dylibso.chicory.runtime.ConstantEvaluators.computeConstantValue; +import static java.lang.Math.min; + +import com.dylibso.chicory.runtime.alloc.MemAllocStrategy; +import com.dylibso.chicory.wasm.ChicoryException; +import com.dylibso.chicory.wasm.UninstantiableException; +import com.dylibso.chicory.wasm.types.ActiveDataSegment; +import com.dylibso.chicory.wasm.types.DataSegment; +import com.dylibso.chicory.wasm.types.MemoryLimits; +import com.dylibso.chicory.wasm.types.PassiveDataSegment; +import java.lang.reflect.InvocationTargetException; +import java.nio.BufferOverflowException; +import java.nio.BufferUnderflowException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.Arrays; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.BooleanSupplier; +import java.util.function.Function; + +/** + * Represents the linear memory in the Wasm program. Can be shared + * reference b/w the host and the guest. + * + * This is the preferred memory implementation on Android systems. + */ +public final class ByteBufferMemory implements Memory { + // Package private for usage as default impl. in Memory. Can become private in next major + // release. + static final Runnable ATOMIC_FENCE_IMPL = getAtomicFenceImpl(); + + // Page addressing constants + private static final int PAGE_SHIFT = 16; // PAGE_SIZE = 65536 = 2^16 + private static final int PAGE_MASK = PAGE_SIZE - 1; + + private final MemoryLimits limits; + private DataSegment[] dataSegments; + + // Page-based storage: fixed-size array of pages, slots filled lazily during grow + // Individual pages are never reallocated once created, enabling lock-free reads + private final ByteBuffer[] pages; + + // Number of currently allocated pages + private volatile int nPages; + + // Lock for grow operation (only used when memory is shared) + private final Object growLock = new Object(); + + public ByteBufferMemory(MemoryLimits limits) { + this.limits = limits; + int maxPages = min(limits.maximumPages(), RUNTIME_MAX_PAGES); + this.pages = new ByteBuffer[maxPages]; + + // Allocate initial pages + for (int i = 0; i < limits.initialPages(); i++) { + pages[i] = ByteBuffer.allocate(PAGE_SIZE).order(ByteOrder.LITTLE_ENDIAN); + } + this.nPages = limits.initialPages(); + + if (limits.shared()) { + waitStates = new ConcurrentHashMap<>(); + } else { + waitStates = null; + } + } + + /** + * @deprecated The MemAllocStrategy is no longer used since memory is allocated by page. + * Use {@link #ByteBufferMemory(MemoryLimits)} instead. + */ + @Deprecated + @SuppressWarnings("InlineMeSuggester") + public ByteBufferMemory(MemoryLimits limits, MemAllocStrategy allocStrategy) { + this(limits); + } + + // Tracks wait state per address: waiter count and pending wakeups + // all field access should be guarded by synchronizing on the instance. + // Invariants: 0 <= pendingWakeups <= waiterCount + private static final class WaitState { + // The number of threads currently waiting + int waiterCount; + // The number of waiting threads that have been scheduled to wake up + int pendingWakeups; + } + + private final Map waitStates; + + @Override + @SuppressWarnings("removal") + public Object lock(int address) { + if (!shared()) { + // disable locking + return new Object(); + } + return waitStates.computeIfAbsent(address, k -> new WaitState()); + } + + // Wait IF condition is true + private int waitOn(int address, BooleanSupplier condition, long timeout) { + if (!shared()) { + throw new ChicoryException("Attempt to wait on a non-shared memory, not supported."); + } + + long deadline = (timeout < 0) ? Long.MAX_VALUE : System.nanoTime() + timeout; + + WaitState state = waitStates.computeIfAbsent(address, k -> new WaitState()); + + synchronized (state) { + // Check the condition while holding the lock + // This must be atomic with the decision to wait + if (!condition.getAsBoolean()) { + return 1; // not-equal + } + + state.waiterCount++; + try { + + while (state.pendingWakeups == 0) { + long remaining = deadline - System.nanoTime(); + if (remaining <= 0) { + return 2; // timeout + } + long millis = Math.max(remaining / 1_000_000L, 0); + int nanos = Math.max((int) (remaining % 1_000_000L), 0); + try { + state.wait(millis, nanos); + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + throw new ChicoryInterruptedException("Thread interrupted"); + } + } + return 0; // woken + } finally { + + if (state.pendingWakeups > 0) { + // any thread leaving the try block is correct to consume + // a pending wakeup IF available: + // ret 0 - woken thread correctly consumes a wakeup + // ret 2 - timeout can only occur with pendingWakeups == 0 so will not consume + // throw - isn't part of the wasm runtime but is semantically correct to consume + state.pendingWakeups--; + } + state.waiterCount--; + assert (0 <= state.pendingWakeups); + assert (state.pendingWakeups <= state.waiterCount); + } + } + } + + @Override + @SuppressWarnings("removal") + public int waitOn(int address, int expected, long timeout) { + return waitOn(address, () -> readInt(address) == expected, timeout); + } + + @Override + @SuppressWarnings("removal") + public int waitOn(int address, long expected, long timeout) { + return waitOn(address, () -> readLong(address) == expected, timeout); + } + + // Notify waiters at this address + @Override + @SuppressWarnings("removal") + public int notify(int address, int maxThreads) { + if (!shared()) { + return 0; + } + + WaitState state = waitStates.get(address); + if (state == null) { + return 0; + } + + synchronized (state) { + int actualWaiters = state.waiterCount - state.pendingWakeups; + + if (actualWaiters == 0) { + return 0; + } + + // Calculate how many to wake: min(actualWaiters, maxThreads) + int toWake; + if (maxThreads < 0) { + toWake = actualWaiters; // wake all + } else { + toWake = Math.min(actualWaiters, maxThreads); + } + + // Add pending wakeups - waiters will consume these + state.pendingWakeups += toWake; + assert (state.pendingWakeups <= state.waiterCount); + + // It's always safe to notify all. In the wait routine we consume pendingWakeups + // and go back to waiting if there are none. We could also choose to notify waiters + // one by one in a loop. The optimal choice of whether to notify all should be + // toWake > C * state.waiterCount, where C is an unknown constant weighing the cost + // of looping through notify vs. having threads wake and go back to waiting. Since + // the constant is unknown we opt for the simplest choice of just notifying all. + state.notifyAll(); + + return toWake; + } + } + + /** + * Gets the size of the memory in number of pages + */ + @Override + public int pages() { + return nPages; + } + + @Override + public int grow(int size) { + if (!shared()) { + return growImpl(size); + } + synchronized (growLock) { + return growImpl(size); + } + } + + private int growImpl(int size) { + int prevPages = nPages; + int numPages = prevPages + size; + + if (numPages > maximumPages() || numPages < prevPages) { + return -1; + } + + // Allocate new pages + for (int i = prevPages; i < numPages; i++) { + pages[i] = ByteBuffer.allocate(PAGE_SIZE).order(ByteOrder.LITTLE_ENDIAN); + } + + // Publish new page count (volatile write ensures visibility of new pages) + nPages = numPages; + return prevPages; + } + + @Override + public int initialPages() { + return this.limits.initialPages(); + } + + @Override + public int maximumPages() { + return min(this.limits.maximumPages(), RUNTIME_MAX_PAGES); + } + + @Override + public boolean shared() { + return this.limits.shared(); + } + + @Override + public void initialize(Instance instance, DataSegment[] dataSegments) { + this.dataSegments = dataSegments; + if (dataSegments == null) { + return; + } + + for (var s : dataSegments) { + if (s instanceof ActiveDataSegment) { + var segment = (ActiveDataSegment) s; + var offsetExpr = segment.offsetInstructions(); + var data = segment.data(); + var offset = (int) computeConstantValue(instance, offsetExpr)[0]; + checkBounds(offset, data.length, sizeInBytes(), UninstantiableException::new); + write(offset, data, 0, data.length); + } else if (s instanceof PassiveDataSegment) { + // Passive segment should be skipped + } else { + throw new ChicoryException("Data segment should be active or passive: " + s); + } + } + } + + private static void checkBounds( + int addr, int size, int limit, Function exceptionFactory) { + if (addr < 0 || size < 0 || addr > limit || (size > 0 && ((addr + size) > limit))) { + var errorMsg = + "out of bounds memory access: attempted to access address: " + + addr + + " but limit is: " + + limit + + " and size: " + + size; + throw exceptionFactory.apply(errorMsg); + } + } + + private RuntimeException outOfBoundsException(RuntimeException e, int addr, int size) { + if (e instanceof IndexOutOfBoundsException + || e instanceof BufferOverflowException + || e instanceof BufferUnderflowException + || e instanceof IllegalArgumentException + || e instanceof NullPointerException + || e instanceof NegativeArraySizeException) { + var limit = sizeInBytes(); + var errorMsg = + "out of bounds memory access: attempted to access address: " + + addr + + " but limit is: " + + limit + + " and size: " + + size; + return new WasmRuntimeException(errorMsg); + } else { + return e; + } + } + + @Override + public void initPassiveSegment(int segmentId, int dest, int offset, int size) { + var segment = dataSegments[segmentId]; + write(dest, segment.data(), offset, size); + } + + private int sizeInBytes() { + return PAGE_SIZE * nPages; + } + + @Override + public void write(int addr, byte[] data, int offset, int size) { + checkBounds(offset, size, data.length, WasmRuntimeException::new); + checkBounds(addr, size, sizeInBytes(), WasmRuntimeException::new); + while (size > 0) { + int pageIdx = addr >>> PAGE_SHIFT; + int pageOffset = addr & PAGE_MASK; + int chunk = Math.min(size, PAGE_SIZE - pageOffset); + pages[pageIdx].position(pageOffset); + pages[pageIdx].put(data, offset, chunk); + addr += chunk; + offset += chunk; + size -= chunk; + } + } + + @Override + public byte read(int addr) { + try { + return pages[addr >>> PAGE_SHIFT].get(addr & PAGE_MASK); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public byte[] readBytes(int addr, int len) { + checkBounds(addr, len, sizeInBytes(), WasmRuntimeException::new); + byte[] result = new byte[len]; + int destOffset = 0; + int remaining = len; + int a = addr; + while (remaining > 0) { + int pageIdx = a >>> PAGE_SHIFT; + int pageOffset = a & PAGE_MASK; + int chunk = Math.min(remaining, PAGE_SIZE - pageOffset); + pages[pageIdx].position(pageOffset); + pages[pageIdx].get(result, destOffset, chunk); + a += chunk; + destOffset += chunk; + remaining -= chunk; + } + return result; + } + + @Override + public void writeI32(int addr, int data) { + int off = addr & PAGE_MASK; + if (off + 4 <= PAGE_SIZE) { + try { + pages[addr >>> PAGE_SHIFT].putInt(off, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } else { + writeI32Slow(addr, data); + } + } + + private void writeI32Slow(int addr, int data) { + checkBounds(addr, 4, sizeInBytes(), WasmRuntimeException::new); + writeByte(addr, (byte) data); + writeByte(addr + 1, (byte) (data >>> 8)); + writeByte(addr + 2, (byte) (data >>> 16)); + writeByte(addr + 3, (byte) (data >>> 24)); + } + + @Override + public int readInt(int addr) { + int off = addr & PAGE_MASK; + if (off + 4 <= PAGE_SIZE) { + try { + return pages[addr >>> PAGE_SHIFT].getInt(off); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } else { + return readIntSlow(addr); + } + } + + private int readIntSlow(int addr) { + return (read(addr) & 0xFF) + | ((read(addr + 1) & 0xFF) << 8) + | ((read(addr + 2) & 0xFF) << 16) + | ((read(addr + 3) & 0xFF) << 24); + } + + @Override + public void writeLong(int addr, long data) { + int off = addr & PAGE_MASK; + if (off + 8 <= PAGE_SIZE) { + try { + pages[addr >>> PAGE_SHIFT].putLong(off, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } else { + writeLongSlow(addr, data); + } + } + + private void writeLongSlow(int addr, long data) { + checkBounds(addr, 8, sizeInBytes(), WasmRuntimeException::new); + writeByte(addr, (byte) data); + writeByte(addr + 1, (byte) (data >>> 8)); + writeByte(addr + 2, (byte) (data >>> 16)); + writeByte(addr + 3, (byte) (data >>> 24)); + writeByte(addr + 4, (byte) (data >>> 32)); + writeByte(addr + 5, (byte) (data >>> 40)); + writeByte(addr + 6, (byte) (data >>> 48)); + writeByte(addr + 7, (byte) (data >>> 56)); + } + + @Override + public long readLong(int addr) { + int off = addr & PAGE_MASK; + if (off + 8 <= PAGE_SIZE) { + try { + return pages[addr >>> PAGE_SHIFT].getLong(off); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } else { + return readLongSlow(addr); + } + } + + private long readLongSlow(int addr) { + return (read(addr) & 0xFFL) + | ((read(addr + 1) & 0xFFL) << 8) + | ((read(addr + 2) & 0xFFL) << 16) + | ((read(addr + 3) & 0xFFL) << 24) + | ((read(addr + 4) & 0xFFL) << 32) + | ((read(addr + 5) & 0xFFL) << 40) + | ((read(addr + 6) & 0xFFL) << 48) + | ((read(addr + 7) & 0xFFL) << 56); + } + + @Override + public void writeShort(int addr, short data) { + int off = addr & PAGE_MASK; + if (off + 2 <= PAGE_SIZE) { + try { + pages[addr >>> PAGE_SHIFT].putShort(off, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } else { + writeShortSlow(addr, data); + } + } + + private void writeShortSlow(int addr, short data) { + checkBounds(addr, 2, sizeInBytes(), WasmRuntimeException::new); + writeByte(addr, (byte) data); + writeByte(addr + 1, (byte) (data >>> 8)); + } + + @Override + public short readShort(int addr) { + int off = addr & PAGE_MASK; + if (off + 2 <= PAGE_SIZE) { + try { + return pages[addr >>> PAGE_SHIFT].getShort(off); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 2); + } + } else { + return readShortSlow(addr); + } + } + + private short readShortSlow(int addr) { + return (short) ((read(addr) & 0xFF) | ((read(addr + 1) & 0xFF) << 8)); + } + + @Override + public long readU16(int addr) { + return readShort(addr) & 0xFFFFL; + } + + @Override + public void writeByte(int addr, byte data) { + try { + pages[addr >>> PAGE_SHIFT].put(addr & PAGE_MASK, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 1); + } + } + + @Override + public void writeF32(int addr, float data) { + int off = addr & PAGE_MASK; + if (off + 4 <= PAGE_SIZE) { + try { + pages[addr >>> PAGE_SHIFT].putFloat(off, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } else { + writeI32Slow(addr, Float.floatToRawIntBits(data)); + } + } + + @Override + public long readF32(int addr) { + return readInt(addr); + } + + @Override + public float readFloat(int addr) { + int off = addr & PAGE_MASK; + if (off + 4 <= PAGE_SIZE) { + try { + return pages[addr >>> PAGE_SHIFT].getFloat(off); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 4); + } + } else { + return Float.intBitsToFloat(readIntSlow(addr)); + } + } + + @Override + public void writeF64(int addr, double data) { + int off = addr & PAGE_MASK; + if (off + 8 <= PAGE_SIZE) { + try { + pages[addr >>> PAGE_SHIFT].putDouble(off, data); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } else { + writeLongSlow(addr, Double.doubleToRawLongBits(data)); + } + } + + @Override + public double readDouble(int addr) { + int off = addr & PAGE_MASK; + if (off + 8 <= PAGE_SIZE) { + try { + return pages[addr >>> PAGE_SHIFT].getDouble(off); + } catch (RuntimeException e) { + throw outOfBoundsException(e, addr, 8); + } + } else { + return Double.longBitsToDouble(readLongSlow(addr)); + } + } + + @Override + public long readF64(int addr) { + return readLong(addr); + } + + @Override + public void zero() { + fill((byte) 0, 0, sizeInBytes()); + } + + @Override + @SuppressWarnings("ByteBufferBackingArray") + public void fill(byte value, int fromIndex, int toIndex) { + int addr = fromIndex; + int remaining = toIndex - fromIndex; + checkBounds(addr, remaining, sizeInBytes(), WasmRuntimeException::new); + while (remaining > 0) { + int pageIdx = addr >>> PAGE_SHIFT; + int pageOffset = addr & PAGE_MASK; + int chunk = Math.min(remaining, PAGE_SIZE - pageOffset); + Arrays.fill(pages[pageIdx].array(), pageOffset, pageOffset + chunk, value); + addr += chunk; + remaining -= chunk; + } + } + + @Override + public void drop(int segment) { + dataSegments[segment] = PassiveDataSegment.EMPTY; + } + + private static Runnable getAtomicFenceImpl() { + try { + // to take into account older Android API level: + // https://developer.android.com/reference/java/lang/invoke/VarHandle#fullFence() + java.lang.invoke.VarHandle.fullFence(); + return java.lang.invoke.VarHandle::fullFence; + } catch (NoSuchMethodError e) { + try { + Class unsafeClass = Class.forName("sun.misc.Unsafe"); + var theUnsafeField = unsafeClass.getDeclaredField("theUnsafe"); + theUnsafeField.setAccessible(true); + var theUnsafe = theUnsafeField.get(null); + var fullFence = unsafeClass.getMethod("fullFence"); + + return () -> { + try { + fullFence.invoke(theUnsafe); + } catch (IllegalAccessException | InvocationTargetException ex) { + throw new RuntimeException( + "ATOMIC_FENCE implementation: Failed to invoke" + + " sun.misc.Unsafe", + ex); + } + }; + } catch (Throwable ex) { + throw new RuntimeException( + "ATOMIC_FENCE implementation: Failed to lookup sun.misc.Unsafe", ex); + } + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ChicoryInterruptedException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ChicoryInterruptedException.java new file mode 100644 index 000000000..829d132ac --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ChicoryInterruptedException.java @@ -0,0 +1,17 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.ChicoryException; + +public class ChicoryInterruptedException extends ChicoryException { + public ChicoryInterruptedException(String msg) { + super(msg); + } + + public ChicoryInterruptedException(Throwable cause) { + super(cause); + } + + public ChicoryInterruptedException(String msg, Throwable cause) { + super(msg, cause); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/CompiledModule.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/CompiledModule.java new file mode 100644 index 000000000..b38fa5556 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/CompiledModule.java @@ -0,0 +1,13 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.WasmModule; +import java.util.function.Function; + +/** + * This interface is implemented by build time compiled wasm modules. + */ +public interface CompiledModule { + WasmModule wasmModule(); + + Function machineFactory(); +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ConstantEvaluators.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ConstantEvaluators.java new file mode 100644 index 000000000..d958912ac --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ConstantEvaluators.java @@ -0,0 +1,121 @@ +package com.dylibso.chicory.runtime; + +import static com.dylibso.chicory.wasm.types.OpCode.GLOBAL_GET; + +import com.dylibso.chicory.wasm.MalformedException; +import com.dylibso.chicory.wasm.types.Instruction; +import com.dylibso.chicory.wasm.types.ValType; +import com.dylibso.chicory.wasm.types.Value; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.List; + +final class ConstantEvaluators { + private ConstantEvaluators() {} + + public static long[] computeConstantValue(Instance instance, Instruction[] expr) { + return computeConstantValue(instance, Arrays.asList(expr)); + } + + public static long[] computeConstantValue(Instance instance, List expr) { + var stack = new ArrayDeque(); + for (var instruction : expr) { + switch (instruction.opcode()) { + case I32_ADD: + { + var x = (int) stack.pop()[0]; + var y = (int) stack.pop()[0]; + stack.push(new long[] {x + y}); + break; + } + case I32_SUB: + { + var x = (int) stack.pop()[0]; + var y = (int) stack.pop()[0]; + stack.push(new long[] {y - x}); + break; + } + case I32_MUL: + { + var x = (int) stack.pop()[0]; + var y = (int) stack.pop()[0]; + int res = x * y; + stack.push(new long[] {res}); + break; + } + case I64_ADD: + { + var x = stack.pop()[0]; + var y = stack.pop()[0]; + stack.push(new long[] {x + y}); + break; + } + case I64_SUB: + { + var x = stack.pop()[0]; + var y = stack.pop()[0]; + stack.push(new long[] {y - x}); + break; + } + case I64_MUL: + { + var x = stack.pop()[0]; + var y = stack.pop()[0]; + stack.push(new long[] {x * y}); + break; + } + case V128_CONST: + { + stack.push(new long[] {instruction.operand(0), instruction.operand(1)}); + break; + } + case F32_CONST: + case F64_CONST: + case I32_CONST: + case I64_CONST: + case REF_FUNC: + { + stack.push(new long[] {instruction.operand(0)}); + break; + } + case REF_NULL: + { + stack.push(new long[] {Value.REF_NULL_VALUE}); + break; + } + case GLOBAL_GET: + { + var idx = (int) instruction.operand(0); + if (instance.global(idx).getType().equals(ValType.V128)) { + stack.push( + new long[] { + instance.global(idx).getValueLow(), + instance.global(idx).getValueHigh() + }); + } else { + stack.push(new long[] {instance.global(idx).getValueLow()}); + } + break; + } + case END: + { + break; + } + default: + throw new MalformedException( + "Invalid instruction in constant value" + instruction); + } + } + + return stack.pop(); + } + + public static Instance computeConstantInstance(Instance instance, List expr) { + for (Instruction instruction : expr) { + if (instruction.opcode() == GLOBAL_GET) { + return instance.global((int) instruction.operand(0)).getInstance(); + } + } + return instance; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/CtrlFrame.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/CtrlFrame.java new file mode 100644 index 000000000..0a67a2d30 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/CtrlFrame.java @@ -0,0 +1,30 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.types.OpCode; + +final class CtrlFrame { + // OpCode of the current Control Flow instruction + public final OpCode opCode; + // params or inputs + public final int startValues; + // returns or outputs + public final int endValues; + // the height of the stack before entering the current Control Flow instruction + public final int height; + + // the program counter of a TRY_TABLE block + // TODO: do we have a better way of doing this? + public final int pc; + + public CtrlFrame(OpCode opCode, int startValues, int endValues, int height) { + this(opCode, startValues, endValues, height, 0); + } + + public CtrlFrame(OpCode opCode, int startValues, int endValues, int height, int pc) { + this.opCode = opCode; + this.startValues = startValues; + this.endValues = endValues; + this.height = height; + this.pc = pc; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ExecutionListener.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ExecutionListener.java new file mode 100644 index 000000000..afc5c6973 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ExecutionListener.java @@ -0,0 +1,17 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.types.Instruction; + +@FunctionalInterface +public interface ExecutionListener { + /* + * WARNING: + * + * Implementing this function you will be executing code on the very hot path of the interpreter for each and every instruction. + * Any issue or performance degradation caused by this code is not going to be supported. + * This interface along with its usage is experimental and we might drop it at a later stage. + * + * If you have a specific use case for this functionality, please, open an Issue at: https://github.com/dylibso/chicory/issues + */ + void onExecution(Instruction instruction, MStack stack); +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ExportFunction.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ExportFunction.java new file mode 100644 index 000000000..1deae190f --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ExportFunction.java @@ -0,0 +1,11 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.ChicoryException; + +/** + * This represents an Exported function from the Wasm module. + */ +@FunctionalInterface +public interface ExportFunction { + long[] apply(long... args) throws ChicoryException; +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/GlobalInstance.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/GlobalInstance.java new file mode 100644 index 000000000..548f8183f --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/GlobalInstance.java @@ -0,0 +1,91 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.types.MutabilityType; +import com.dylibso.chicory.wasm.types.ValType; +import com.dylibso.chicory.wasm.types.Value; +import com.dylibso.chicory.wasm.types.ValueType; + +public class GlobalInstance { + private long valueLow; + private long valueHigh; + private final ValType valType; + private Instance instance; + private final MutabilityType mutabilityType; + + public GlobalInstance(Value value) { + this(value, MutabilityType.Const); + } + + public GlobalInstance(Value value, MutabilityType mutabilityType) { + this.valueLow = value.raw(); + this.valueHigh = 0; + this.valType = value.type(); + this.mutabilityType = mutabilityType; + } + + /** + * @deprecated use {@link #GlobalInstance(long, long, ValType, MutabilityType)} + */ + @Deprecated(since = "1.3.0") + public GlobalInstance( + long valueLow, long valueHigh, ValueType valueType, MutabilityType mutabilityType) { + this.valueLow = valueLow; + this.valueHigh = valueHigh; + this.valType = valueType.toValType(); + this.mutabilityType = mutabilityType; + } + + public GlobalInstance( + long valueLow, long valueHigh, ValType valType, MutabilityType mutabilityType) { + this.valueLow = valueLow; + this.valueHigh = valueHigh; + this.valType = valType; + this.mutabilityType = mutabilityType; + } + + public long getValueLow() { + return valueLow; + } + + public long getValueHigh() { + return valueHigh; + } + + public long getValue() { + return valueLow; + } + + public ValType getType() { + return valType; + } + + public void setValue(Value value) { + // globals can not be type polimorphic + assert (value.type() == valType); + this.valueLow = value.raw(); + } + + public void setValue(long value) { + this.valueLow = value; + } + + public void setValueLow(long value) { + this.valueLow = value; + } + + public void setValueHigh(long value) { + this.valueHigh = value; + } + + public Instance getInstance() { + return instance; + } + + public void setInstance(Instance instance) { + this.instance = instance; + } + + public MutabilityType getMutabilityType() { + return mutabilityType; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/HostFunction.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/HostFunction.java new file mode 100644 index 000000000..d43074932 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/HostFunction.java @@ -0,0 +1,31 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.types.FunctionType; +import java.util.List; + +/** + * A HostFunction is an ExternalFunction that has been defined by the host. + */ +public class HostFunction extends ImportFunction { + /** + * @deprecated use {@link #HostFunction(String, String, FunctionType, WasmFunctionHandle)} + */ + @Deprecated(since = "1.3.0") + public HostFunction( + String moduleName, + String symbolName, + List paramTypes, + List returnTypes, + WasmFunctionHandle handle) { + super( + moduleName, + symbolName, + FunctionType.of(convert(paramTypes), convert(returnTypes)), + handle); + } + + public HostFunction( + String moduleName, String symbolName, FunctionType type, WasmFunctionHandle handle) { + super(moduleName, symbolName, type, handle); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportFunction.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportFunction.java new file mode 100644 index 000000000..ec702e45e --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportFunction.java @@ -0,0 +1,86 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.ValType; +import com.dylibso.chicory.wasm.types.ValueType; +import java.util.ArrayList; +import java.util.List; + +public class ImportFunction implements ImportValue { + private final String module; + private final String name; + private final List paramTypes; + private final List returnTypes; + private final WasmFunctionHandle handle; + + @Deprecated(since = "1.3.0") + protected static List convert(List objs) { + var result = new ArrayList(objs.size()); + for (var v : objs) { + if (v instanceof ValType) { + result.add((ValType) v); + } else if (v instanceof ValueType) { + result.add(((ValueType) v).toValType()); + } else { + throw new IllegalArgumentException( + "Expected ValueType or ValType, but got: " + + v.getClass().getCanonicalName()); + } + } + return result; + } + + public ImportFunction( + String module, String name, FunctionType type, WasmFunctionHandle handle) { + this.module = module; + this.name = name; + this.paramTypes = type.params(); + this.returnTypes = type.returns(); + this.handle = handle; + } + + @Deprecated(since = "1.3.0") + public ImportFunction( + String module, + String name, + List paramTypes, + List returnTypes, + WasmFunctionHandle handle) { + this.module = module; + this.name = name; + this.paramTypes = convert(paramTypes); + this.returnTypes = convert(returnTypes); + this.handle = handle; + } + + public WasmFunctionHandle handle() { + return handle; + } + + @Override + public String module() { + return module; + } + + @Override + public String name() { + return name; + } + + @Override + public Type type() { + return Type.FUNCTION; + } + + public List paramTypes() { + return paramTypes; + } + + public List returnTypes() { + return returnTypes; + } + + public FunctionType functionType() { + return FunctionType.of(paramTypes, returnTypes); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportGlobal.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportGlobal.java new file mode 100644 index 000000000..091cb93f7 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportGlobal.java @@ -0,0 +1,32 @@ +package com.dylibso.chicory.runtime; + +public class ImportGlobal implements ImportValue { + private final GlobalInstance instance; + private final String module; + private final String name; + + public ImportGlobal(String module, String name, GlobalInstance instance) { + this.instance = instance; + this.module = module; + this.name = name; + } + + public GlobalInstance instance() { + return instance; + } + + @Override + public String module() { + return module; + } + + @Override + public String name() { + return name; + } + + @Override + public ImportValue.Type type() { + return Type.GLOBAL; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportMemory.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportMemory.java new file mode 100644 index 000000000..b6394418f --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportMemory.java @@ -0,0 +1,32 @@ +package com.dylibso.chicory.runtime; + +public class ImportMemory implements ImportValue { + private final String module; + private final String name; + private final Memory memory; + + public ImportMemory(String module, String name, Memory memory) { + this.module = module; + this.name = name; + this.memory = memory; + } + + @Override + public String module() { + return module; + } + + @Override + public String name() { + return name; + } + + @Override + public ImportValue.Type type() { + return Type.MEMORY; + } + + public Memory memory() { + return memory; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportTable.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportTable.java new file mode 100644 index 000000000..e9c836507 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportTable.java @@ -0,0 +1,57 @@ +package com.dylibso.chicory.runtime; + +import static com.dylibso.chicory.wasm.types.Value.REF_NULL_VALUE; + +import com.dylibso.chicory.wasm.types.Table; +import com.dylibso.chicory.wasm.types.TableLimits; +import com.dylibso.chicory.wasm.types.ValType; +import java.util.Map; + +public class ImportTable implements ImportValue { + private final String module; + private final String name; + private final TableInstance table; + + public ImportTable(String module, String name, TableInstance table) { + this.module = module; + this.name = name; + this.table = table; + } + + public ImportTable(String module, String name, Map funcRefs) { + this.module = module; + this.name = name; + + long maxFuncRef = 0; + for (var k : funcRefs.keySet()) { + if (k > maxFuncRef) { + maxFuncRef = k; + } + } + + this.table = + new TableInstance( + new Table(ValType.FuncRef, new TableLimits(maxFuncRef, maxFuncRef)), + REF_NULL_VALUE); + this.table.reset(); + } + + @Override + public String module() { + return module; + } + + @Override + public String name() { + return name; + } + + @Override + public ImportValue.Type type() { + return Type.TABLE; + } + + public TableInstance table() { + return table; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportTag.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportTag.java new file mode 100644 index 000000000..21a471cc5 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportTag.java @@ -0,0 +1,32 @@ +package com.dylibso.chicory.runtime; + +public class ImportTag implements ImportValue { + private final String module; + private final String name; + private final TagInstance tag; + + public ImportTag(String module, String name, TagInstance tag) { + this.module = module; + this.name = name; + this.tag = tag; + } + + @Override + public String module() { + return module; + } + + @Override + public String name() { + return name; + } + + @Override + public Type type() { + return Type.TAG; + } + + public TagInstance tag() { + return tag; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportValue.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportValue.java new file mode 100644 index 000000000..70ca6258c --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportValue.java @@ -0,0 +1,26 @@ +package com.dylibso.chicory.runtime; + +/** + * An external value is the runtime representation of an entity that can be imported. + * It is an address denoting either a function instance, table instance, memory instance, + * or global instances in the shared store. + * + * See also External Values. + * + * @see ExportFunction + */ +public interface ImportValue { + enum Type { + FUNCTION, + GLOBAL, + MEMORY, + TABLE, + TAG + } + + String module(); + + String name(); + + ImportValue.Type type(); +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportValues.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportValues.java new file mode 100644 index 000000000..1b00f0948 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/ImportValues.java @@ -0,0 +1,194 @@ +package com.dylibso.chicory.runtime; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; + +public final class ImportValues { + private static final ImportFunction[] NO_EXTERNAL_FUNCTIONS = new ImportFunction[0]; + private static final ImportGlobal[] NO_EXTERNAL_GLOBALS = new ImportGlobal[0]; + private static final ImportMemory[] NO_EXTERNAL_MEMORIES = new ImportMemory[0]; + private static final ImportTable[] NO_EXTERNAL_TABLES = new ImportTable[0]; + private static final ImportTag[] NO_EXTERNAL_TAGS = new ImportTag[0]; + + private final ImportFunction[] functions; + private final ImportGlobal[] globals; + private final ImportMemory[] memories; + private final ImportTable[] tables; + private final ImportTag[] tags; + + private ImportValues( + ImportFunction[] functions, + ImportGlobal[] globals, + ImportMemory[] memories, + ImportTable[] tables, + ImportTag[] tags) { + this.functions = functions.clone(); + this.globals = globals.clone(); + this.memories = memories.clone(); + this.tables = tables.clone(); + this.tags = tags.clone(); + } + + public ImportFunction[] functions() { + return functions.clone(); + } + + public int functionCount() { + return functions.length; + } + + public ImportFunction function(int idx) { + return functions[idx]; + } + + public ImportGlobal[] globals() { + return globals; + } + + public int globalCount() { + return globals.length; + } + + public ImportGlobal global(int idx) { + return globals[idx]; + } + + public ImportMemory[] memories() { + return memories; + } + + public int memoryCount() { + return memories.length; + } + + public ImportMemory memory(int idx) { + return memories[idx]; + } + + public ImportTable[] tables() { + return tables; + } + + public int tableCount() { + return tables.length; + } + + public ImportTable table(int idx) { + return tables[idx]; + } + + public ImportTag[] tags() { + return tags; + } + + public int tagCount() { + return tags.length; + } + + public ImportTag tag(int idx) { + return tags[idx]; + } + + public static Builder builder() { + return new Builder(); + } + + public static ImportValues empty() { + return new Builder().build(); + } + + public static final class Builder { + private Collection functions; + private Collection globals; + private Collection memories; + private Collection tables; + private Collection tags; + + Builder() {} + + public Builder withFunctions(Collection functions) { + this.functions = functions; + return this; + } + + public Builder addFunction(ImportFunction... function) { + if (this.functions == null) { + this.functions = new ArrayList<>(); + } + Collections.addAll(this.functions, function); + return this; + } + + public Builder withGlobals(Collection globals) { + this.globals = globals; + return this; + } + + public Builder addGlobal(ImportGlobal... global) { + if (this.globals == null) { + this.globals = new ArrayList<>(); + } + Collections.addAll(this.globals, global); + return this; + } + + public Builder withMemories(Collection memories) { + this.memories = memories; + return this; + } + + public Builder addMemory(ImportMemory... memory) { + if (this.memories == null) { + this.memories = new ArrayList<>(); + } + Collections.addAll(this.memories, memory); + return this; + } + + public Builder withTables(Collection tables) { + this.tables = tables; + return this; + } + + public Builder addTable(ImportTable... table) { + if (this.tables == null) { + this.tables = new ArrayList<>(); + } + Collections.addAll(this.tables, table); + return this; + } + + public Builder withTags(Collection tags) { + this.tags = tags; + return this; + } + + public Builder addTag(ImportTag... tag) { + if (this.tags == null) { + this.tags = new ArrayList<>(); + } + Collections.addAll(this.tags, tag); + return this; + } + + public ImportValues build() { + final ImportValues importValues = + new ImportValues( + functions == null + ? NO_EXTERNAL_FUNCTIONS + : functions.toArray(NO_EXTERNAL_FUNCTIONS), + globals == null + ? NO_EXTERNAL_GLOBALS + : globals.toArray(NO_EXTERNAL_GLOBALS), + memories == null + ? NO_EXTERNAL_MEMORIES + : memories.toArray(NO_EXTERNAL_MEMORIES), + tables == null + ? NO_EXTERNAL_TABLES + : tables.toArray(NO_EXTERNAL_TABLES), + tags == null ? NO_EXTERNAL_TAGS : tags.toArray(NO_EXTERNAL_TAGS)); + return importValues; + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Instance.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Instance.java new file mode 100644 index 000000000..7c1e95bfb --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Instance.java @@ -0,0 +1,892 @@ +package com.dylibso.chicory.runtime; + +import static com.dylibso.chicory.runtime.ConstantEvaluators.computeConstantInstance; +import static com.dylibso.chicory.runtime.ConstantEvaluators.computeConstantValue; +import static com.dylibso.chicory.wasm.types.ExternalType.FUNCTION; +import static com.dylibso.chicory.wasm.types.ExternalType.GLOBAL; +import static com.dylibso.chicory.wasm.types.ExternalType.MEMORY; +import static com.dylibso.chicory.wasm.types.ExternalType.TABLE; +import static com.dylibso.chicory.wasm.types.ExternalType.TAG; +import static java.util.Objects.requireNonNullElse; +import static java.util.Objects.requireNonNullElseGet; + +import com.dylibso.chicory.wasm.ChicoryException; +import com.dylibso.chicory.wasm.InvalidException; +import com.dylibso.chicory.wasm.UninstantiableException; +import com.dylibso.chicory.wasm.UnlinkableException; +import com.dylibso.chicory.wasm.WasmModule; +import com.dylibso.chicory.wasm.types.ActiveDataSegment; +import com.dylibso.chicory.wasm.types.ActiveElement; +import com.dylibso.chicory.wasm.types.DataSegment; +import com.dylibso.chicory.wasm.types.Element; +import com.dylibso.chicory.wasm.types.Export; +import com.dylibso.chicory.wasm.types.ExportSection; +import com.dylibso.chicory.wasm.types.ExternalType; +import com.dylibso.chicory.wasm.types.FunctionBody; +import com.dylibso.chicory.wasm.types.FunctionImport; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.Global; +import com.dylibso.chicory.wasm.types.GlobalImport; +import com.dylibso.chicory.wasm.types.Import; +import com.dylibso.chicory.wasm.types.Instruction; +import com.dylibso.chicory.wasm.types.MemoryImport; +import com.dylibso.chicory.wasm.types.MemoryLimits; +import com.dylibso.chicory.wasm.types.MemorySection; +import com.dylibso.chicory.wasm.types.MutabilityType; +import com.dylibso.chicory.wasm.types.Table; +import com.dylibso.chicory.wasm.types.TableImport; +import com.dylibso.chicory.wasm.types.TagImport; +import com.dylibso.chicory.wasm.types.TagSection; +import com.dylibso.chicory.wasm.types.TagType; +import com.dylibso.chicory.wasm.types.ValType; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.function.Function; +import java.util.stream.Collectors; + +public class Instance { + public static final String START_FUNCTION_NAME = "_start"; + + private final WasmModule module; + private final Machine machine; + private final FunctionBody[] functions; + private final Memory memory; + private final DataSegment[] dataSegments; + private final Global[] globalInitializers; + private final GlobalInstance[] globals; + private final FunctionType[] types; + private final int[] functionTypes; + private final ImportValues imports; + private final TableInstance[] tables; + private final Element[] elements; + private final TagInstance[] tags; + private final Map exports; + private final ExecutionListener listener; + private final Exports fluentExports; + + private final Map exnRefs; + + Instance( + WasmModule module, + Global[] globalInitializers, + Memory memory, + DataSegment[] dataSegments, + FunctionBody[] functions, + FunctionType[] types, + int[] functionTypes, + ImportValues imports, + Table[] tables, + Element[] elements, + TagType[] tags, + Map exports, + Function machineFactory, + boolean initialize, + boolean start, + ExecutionListener listener) { + this.module = module; + this.globalInitializers = globalInitializers.clone(); + this.globals = new GlobalInstance[globalInitializers.length]; + this.memory = memory; + this.dataSegments = dataSegments; + this.functions = functions.clone(); + this.types = types.clone(); + this.functionTypes = functionTypes.clone(); + this.imports = imports; + this.machine = machineFactory.apply(this); + this.tables = new TableInstance[tables.length]; + this.elements = elements.clone(); + this.tags = (tags == null) ? new TagInstance[0] : new TagInstance[tags.length]; + for (int i = 0; i < this.tags.length; i++) { + this.tags[i] = new TagInstance(tags[i]); + this.tags[i].setType(types[tags[i].typeIdx()]); + } + this.exports = exports; + this.listener = listener; + this.fluentExports = new Exports(this); + + this.exnRefs = new HashMap<>(); + + for (int i = 0; i < tables.length; i++) { + var initValue = (int) computeConstantValue(this, tables[i].initialize())[0]; + this.tables[i] = new TableInstance(tables[i], initValue); + } + + if (initialize) { + initialize(start); + } + } + + public Instance initialize(boolean start) { + for (var el : elements) { + if (el instanceof ActiveElement) { + var ae = (ActiveElement) el; + var table = table(ae.tableIndex()); + int offset = (int) computeConstantValue(this, ae.offset())[0]; + + List> initializers = ae.initializers(); + if (offset > table.limits().min() + || (offset + initializers.size() - 1) >= table.size()) { + throw new UninstantiableException("out of bounds table access"); + } + for (int i = 0; i < initializers.size(); i++) { + final List init = initializers.get(i); + int index = offset + i; + var value = computeConstantValue(this, init); + var inst = computeConstantInstance(this, init); + + assert ae.type().isReference(); + table.setRef(index, (int) value[0], inst); + } + } + } + + for (var i = 0; i < globalInitializers.length; i++) { + var g = globalInitializers[i]; + var values = computeConstantValue(this, g.initInstructions()); + globals[i] = + new GlobalInstance( + values[0], + (values.length > 1) ? values[1] : 0, + g.valueType(), + g.mutabilityType()); + globals[i].setInstance(this); + } + + if (memory != null && imports.memories().length == 0) { + memory.zero(); + memory.initialize(this, dataSegments); + } else if (imports.memories().length > 0) { + imports.memories()[0].memory().initialize(this, dataSegments); + } else if (Arrays.stream(dataSegments).anyMatch(ds -> ds instanceof ActiveDataSegment)) { + for (var ds : dataSegments) { + if (ds instanceof ActiveDataSegment) { + var memory = (ActiveDataSegment) ds; + throw new InvalidException("unknown memory " + memory.index()); + } + } + throw new InvalidException("unknown memory"); + } + + if (this.module.startSection().isPresent()) { + try { + this.machine.call( + (int) this.module.startSection().get().startIndex(), new long[] {}); + } catch (TrapException e) { + throw new UninstantiableException(e.getMessage(), e); + } + } + + Export startFunction = this.exports.get(START_FUNCTION_NAME); + if (startFunction != null && start) { + export(START_FUNCTION_NAME).apply(); + } + + return this; + } + + public FunctionType exportType(String name) { + return type(functionType(exports.get(name).index())); + } + + public static final class Exports { + private final Instance instance; + + private Exports(Instance instance) { + this.instance = instance; + } + + private Export getExport(ExternalType type, String name) throws InvalidException { + var export = instance.exports.get(name); + if (export == null) { + throw new InvalidException("Unknown export with name " + name); + } else if (export.exportType() != type) { + throw new InvalidException( + "The export " + + export.name() + + " is of type " + + export.exportType() + + " and cannot be converted to " + + type); + } + return export; + } + + public ExportFunction function(String name) { + var export = getExport(FUNCTION, name); + return args -> instance.machine.call(export.index(), args); + } + + public GlobalInstance global(String name) { + var export = getExport(GLOBAL, name); + return instance.global(export.index()); + } + + public TableInstance table(String name) { + var export = getExport(TABLE, name); + return instance.table(export.index()); + } + + public Memory memory(String name) { + var export = getExport(MEMORY, name); + assert (export.index() == 0); + return instance.memory(); + } + } + + public Exports exports() { + return fluentExports; + } + + public ExportFunction export(String name) { + return this.fluentExports.function(name); + } + + public FunctionBody function(long idx) { + if (idx < 0 || idx >= (functions.length + imports.functionCount())) { + throw new InvalidException("unknown function " + idx); + } else if (idx < imports.functionCount()) { + return null; + } + return functions[(int) idx - imports.functionCount()]; + } + + public int functionCount() { + return imports.functionCount() + functions.length; + } + + public Memory memory() { + return memory; + } + + public GlobalInstance global(int idx) { + if (idx < imports.globalCount()) { + return imports.global(idx).instance(); + } + var i = idx - imports.globalCount(); + if (i < 0 || i >= globals.length) { + throw new InvalidException("unknown global " + idx); + } + return globals[idx - imports.globalCount()]; + } + + public FunctionType type(int idx) { + if (idx >= types.length) { + throw new InvalidException("unknown type " + idx); + } + return types[idx]; + } + + public int functionType(int idx) { + if (idx >= functionTypes.length) { + throw new InvalidException("unknown function " + idx); + } + return functionTypes[idx]; + } + + public ImportValues imports() { + return imports; + } + + public WasmModule module() { + return module; + } + + public TableInstance table(int idx) { + if (idx < 0 || idx >= (tables.length + imports.tableCount())) { + throw new InvalidException("unknown table " + idx); + } + if (idx < imports.tableCount()) { + return imports.table(idx).table(); + } + return tables[idx - imports.tableCount()]; + } + + public Element element(int idx) { + if (idx < 0 || idx >= elements.length) { + throw new InvalidException("unknown elem segment " + idx); + } + return elements[idx]; + } + + public int elementCount() { + return elements.length; + } + + public void setElement(int idx, Element val) { + elements[idx] = val; + } + + public TagInstance tag(int idx) { + if (idx < imports.tagCount()) { + return imports.tag(idx).tag(); + } + return tags[idx - imports.tagCount()]; + } + + public int tagCount() { + return tags.length; + } + + public int registerException(WasmException ex) { + exnRefs.put(ex.tagIdx(), ex); + return ex.tagIdx(); + } + + public WasmException exn(int idx) { + return exnRefs.get(idx); + } + + public Machine getMachine() { + return machine; + } + + void onExecution(Instruction instruction, MStack stack) { + if (listener != null) { + listener.onExecution(instruction, stack); + } + } + + public static Builder builder(WasmModule module) { + return new Builder(module); + } + + public static final class Builder { + private final WasmModule module; + + private boolean initialize = true; + private boolean start = true; + private MemoryLimits memoryLimits; + private Function memoryFactory; + private ExecutionListener listener; + private ImportValues importValues; + private Function machineFactory; + + private Builder(WasmModule module) { + this.module = Objects.requireNonNull(module); + } + + public Builder withInitialize(boolean init) { + this.initialize = init; + return this; + } + + public Builder withStart(boolean s) { + this.start = s; + return this; + } + + public Builder withMemoryLimits(MemoryLimits limits) { + this.memoryLimits = limits; + return this; + } + + public Builder withMemoryFactory(Function memoryFactory) { + this.memoryFactory = memoryFactory; + return this; + } + + /* + * This method is experimental and might be dropped without notice in future releases. + */ + public Builder withUnsafeExecutionListener(ExecutionListener listener) { + this.listener = listener; + return this; + } + + public Builder withImportValues(ImportValues importValues) { + this.importValues = importValues; + return this; + } + + public Builder withMachineFactory(Function machineFactory) { + this.machineFactory = machineFactory; + return this; + } + + private boolean checkExternalFunctionSignature(FunctionImport imprt, ImportFunction f) { + try { + validateExternalFunctionSignature(imprt, f); + return true; + } catch (UnlinkableException e) { + return false; + } + } + + private void validateExternalFunctionSignature(FunctionImport imprt, ImportFunction f) { + var expectedType = module.typeSection().getType(imprt.typeIndex()); + + if (!f.functionType().equals(expectedType)) { + throw new UnlinkableException( + "incompatible import type for host function " + + f.module() + + "." + + f.name()); + } + } + + private boolean checkHostGlobalType(GlobalImport i, ImportGlobal g) { + try { + validateHostGlobalType(i, g); + return true; + } catch (UnlinkableException e) { + return false; + } + } + + private void validateHostGlobalType(GlobalImport i, ImportGlobal g) { + boolean typesMatch; + + if (i.mutabilityType() == MutabilityType.Var) { + // for mutable globals, types must match exactly + typesMatch = i.type().equals(g.instance().getType()); + } else if (i.mutabilityType() == MutabilityType.Const) { + // for const, subtyping is allowed + typesMatch = ValType.matches(g.instance().getType(), i.type()); + } else { + throw new ChicoryException( + "internal error: mutability type is not var or const: " + + i.mutabilityType()); + } + + if (!typesMatch || i.mutabilityType() != g.instance().getMutabilityType()) { + throw new UnlinkableException("incompatible import type"); + } + } + + private boolean checkHostTagType(TagImport i, ImportTag t) { + try { + validateHostTagType(i, t); + return true; + } catch (UnlinkableException e) { + return false; + } + } + + private void validateHostTagType(TagImport i, ImportTag t) { + var expectedType = module.typeSection().getType(i.tagType().typeIdx()); + var gotType = t.tag().type(); + if (expectedType.params().size() != gotType.params().size() + || expectedType.returns().size() != gotType.returns().size()) { + throw new UnlinkableException( + "incompatible import type for tag " + t.module() + "." + t.name()); + } + for (int j = 0; j < expectedType.params().size(); j++) { + var expected = expectedType.params().get(j); + var got = gotType.params().get(j); + if (!expected.equals(got)) { + throw new UnlinkableException( + "incompatible import type for tag " + t.module() + "." + t.name()); + } + } + for (int j = 0; j < expectedType.returns().size(); j++) { + var expected = expectedType.returns().get(j); + var got = gotType.returns().get(j); + if (!expected.equals(got)) { + throw new UnlinkableException( + "incompatible import type for tag " + t.module() + "." + t.name()); + } + } + } + + private boolean checkHostTableType(TableImport i, ImportTable t) { + try { + validateHostTableType(i, t); + return true; + } catch (UnlinkableException e) { + return false; + } + } + + private void validateHostTableType(TableImport i, ImportTable t) { + var minExpected = t.table().limits().min(); + var maxExpected = t.table().limits().max(); + var minCurrent = i.limits().min(); + var maxCurrent = i.limits().max(); + if (!i.entryType().equals(t.table().elementType())) { + throw new UnlinkableException("incompatible import type"); + } else if (minExpected < minCurrent + || maxExpected > maxCurrent + || t.table().limits().shared() != i.limits().shared()) { + throw new UnlinkableException( + "incompatible import type, non-compatible limits, expected: " + + i.limits() + + ", current: " + + t.table().limits() + + " on table: " + + t.module() + + "." + + t.name()); + } + } + + private void validateHostMemoryType(MemoryImport i, ImportMemory m) { + // Notice we do not compare to m.memory().initialPages() + // because m might have grown in the meantime. + // Instead, we use the current number of pages. + var hostMemCurrentPages = m.memory().pages(); + var hostMemMaxPages = m.memory().maximumPages(); + var importInitialPages = i.limits().initialPages(); + var importMaxPages = + (i.limits().maximumPages() == MemoryLimits.MAX_PAGES) + ? Memory.RUNTIME_MAX_PAGES + : i.limits().maximumPages(); + + // HostMem bounds [x,y] must be within the import bounds [a, b]; i.e., a <= x, y >= b. + // In other words, the bounds are not valid when: + // - HostMem current number of pages cannot be less than the import lower bound. + // - HostMem upper bound cannot be larger than the given upper bound. + if (hostMemCurrentPages < importInitialPages + || hostMemMaxPages > importMaxPages + || m.memory().shared() != i.limits().shared()) { + throw new UnlinkableException( + "incompatible import type, non-compatible limits, import: " + + i.limits() + + ", host initial pages: " + + m.memory().initialPages() + + ", host max pages: " + + m.memory().maximumPages() + + ", host shared: " + + m.memory().shared() + + " on memory: " + + m.module() + + "." + + m.name()); + } + } + + private void validateNegativeImportType( + String moduleName, String name, ImportValue[] external) { + for (var fh : external) { + if (fh.module().equals(moduleName) && fh.name().equals(name)) { + throw new UnlinkableException("incompatible import type"); + } + } + } + + private void validateNegativeImportType( + String moduleName, String name, ExternalType typ, ImportValues importValues) { + switch (typ) { + case FUNCTION: + validateNegativeImportType(moduleName, name, importValues.globals()); + validateNegativeImportType(moduleName, name, importValues.memories()); + validateNegativeImportType(moduleName, name, importValues.tables()); + validateNegativeImportType(moduleName, name, importValues.tags()); + break; + case GLOBAL: + validateNegativeImportType(moduleName, name, importValues.functions()); + validateNegativeImportType(moduleName, name, importValues.memories()); + validateNegativeImportType(moduleName, name, importValues.tables()); + validateNegativeImportType(moduleName, name, importValues.tags()); + break; + case MEMORY: + validateNegativeImportType(moduleName, name, importValues.functions()); + validateNegativeImportType(moduleName, name, importValues.globals()); + validateNegativeImportType(moduleName, name, importValues.tables()); + validateNegativeImportType(moduleName, name, importValues.tags()); + break; + case TABLE: + validateNegativeImportType(moduleName, name, importValues.functions()); + validateNegativeImportType(moduleName, name, importValues.globals()); + validateNegativeImportType(moduleName, name, importValues.memories()); + validateNegativeImportType(moduleName, name, importValues.tags()); + break; + case TAG: + validateNegativeImportType(moduleName, name, importValues.functions()); + validateNegativeImportType(moduleName, name, importValues.globals()); + validateNegativeImportType(moduleName, name, importValues.memories()); + validateNegativeImportType(moduleName, name, importValues.tables()); + break; + } + } + + private ImportValues mapHostImports( + Import[] imports, ImportValues importValues, int memoryCount) { + Function count = + t -> (int) Arrays.stream(imports).filter(i -> i.importType() == t).count(); + + // TODO: this can probably be refactored ... + var hostFuncs = new ImportFunction[count.apply(FUNCTION)]; + var hostFuncIdx = 0; + var hostGlobals = new ImportGlobal[count.apply(GLOBAL)]; + var hostGlobalIdx = 0; + var hostMems = new ImportMemory[count.apply(MEMORY)]; + var hostMemIdx = 0; + var hostTags = new ImportTag[count.apply(TAG)]; + var hostTagIdx = 0; + if (hostMems.length + memoryCount > 1) { + throw new InvalidException("multiple memories"); + } + var hostTables = new ImportTable[count.apply(TABLE)]; + var hostTableIdx = 0; + int cnt; + var names = + Arrays.stream(imports) + .map(i -> i.module() + "." + i.name()) + .collect(Collectors.toList()); + for (var impIdx = 0; impIdx < imports.length; impIdx++) { + var i = imports[impIdx]; + var name = i.module() + "." + i.name(); + var aliases = names.stream().filter(s -> s.equals(name)); + var aliasesCount = aliases.count(); + var aliasNum = 0; + var found = false; + validateNegativeImportType(i.module(), i.name(), i.importType(), importValues); + Function checkName = + (ImportValue fh) -> + i.module().equals(fh.module()) && i.name().equals(fh.name()); + switch (i.importType()) { + case FUNCTION: + cnt = importValues.functionCount(); + for (int j = 0; j < cnt; j++) { + ImportFunction f = importValues.function(j); + if (checkName.apply(f)) { + if (aliasesCount == 1 || ++aliasNum == aliasesCount) { + validateExternalFunctionSignature((FunctionImport) i, f); + } else if (!checkExternalFunctionSignature((FunctionImport) i, f)) { + continue; + } + hostFuncs[hostFuncIdx] = f; + found = true; + break; + } + } + hostFuncIdx++; + break; + case GLOBAL: + cnt = importValues.globalCount(); + for (int j = 0; j < cnt; j++) { + ImportGlobal g = importValues.global(j); + if (checkName.apply(g)) { + if (aliasesCount == 1 || ++aliasNum == aliasesCount) { + validateHostGlobalType((GlobalImport) i, g); + } else if (!checkHostGlobalType((GlobalImport) i, g)) { + continue; + } + hostGlobals[hostGlobalIdx] = g; + found = true; + break; + } + } + hostGlobalIdx++; + break; + case MEMORY: + cnt = importValues.memoryCount(); + for (int j = 0; j < cnt; j++) { + ImportMemory m = importValues.memory(j); + if (checkName.apply(m)) { + validateHostMemoryType((MemoryImport) i, m); + hostMems[hostMemIdx] = m; + found = true; + break; + } + } + hostMemIdx++; + break; + case TABLE: + cnt = importValues.tableCount(); + for (int j = 0; j < cnt; j++) { + ImportTable t = importValues.table(j); + if (checkName.apply(t)) { + if (aliasesCount == 1 || ++aliasNum == aliasesCount) { + validateHostTableType((TableImport) i, t); + } else if (!checkHostTableType((TableImport) i, t)) { + continue; + } + hostTables[hostTableIdx] = t; + found = true; + break; + } + } + hostTableIdx++; + break; + case TAG: + cnt = importValues.tagCount(); + for (int j = 0; j < cnt; j++) { + ImportTag t = importValues.tag(j); + if (checkName.apply(t)) { + if (aliasesCount == 1 || ++aliasNum == aliasesCount) { + validateHostTagType((TagImport) i, t); + } else if (!checkHostTagType((TagImport) i, t)) { + continue; + } + hostTags[hostTagIdx] = t; + found = true; + break; + } + } + hostTagIdx++; + break; + } + if (!found) { + throw new UnlinkableException( + "unknown import, could not find host function for import number: " + + impIdx + + " named " + + name); + } + } + + return ImportValues.builder() + .addFunction(hostFuncs) + .addGlobal(hostGlobals) + .addMemory(hostMems) + .addTable(hostTables) + .addTag(hostTags) + .build(); + } + + private Map genExports(ExportSection export) { + var exports = new HashMap(); + int cnt = export.exportCount(); + for (int i = 0; i < cnt; i++) { + Export e = export.getExport(i); + if (exports.containsKey(e.name())) { + throw new InvalidException("duplicate export name " + e.name()); + } + exports.put(e.name(), e); + } + return exports; + } + + public Instance build() { + Map exports = genExports(module.exportSection()); + var globalInitializers = module.globalSection().globals(); + + var dataSegments = module.dataSection().dataSegments(); + var types = module.typeSection().types(); + int numFuncTypes = + module.functionSection().functionCount() + + module.importSection().count(FUNCTION); + + FunctionBody[] functions = module.codeSection().functionBodies(); + + int importId = 0; + var functionTypes = new int[numFuncTypes]; + var funcIdx = 0; + + int importCount = module.importSection().importCount(); + var imports = new Import[importCount]; + for (int i = 0; i < importCount; i++) { + Import imprt = module.importSection().getImport(i); + if (imprt.importType() == FUNCTION) { + var type = ((FunctionImport) imprt).typeIndex(); + if (type >= this.module.typeSection().typeCount()) { + throw new InvalidException("unknown type"); + } + functionTypes[funcIdx] = type; + funcIdx++; + } + imports[importId++] = imprt; + } + + var mappedHostImports = + mapHostImports( + imports, + requireNonNullElseGet(importValues, ImportValues::empty), + module.memorySection().map(MemorySection::memoryCount).orElse(0)); + + for (int i = 0; i < module.functionSection().functionCount(); i++) { + functionTypes[funcIdx++] = module.functionSection().getFunctionType(i); + } + + var tableLength = module.tableSection().tableCount(); + Table[] tables = new Table[tableLength]; + for (int i = 0; i < tableLength; i++) { + tables[i] = module.tableSection().getTable(i); + } + + Element[] elements = module.elementSection().elements(); + + Memory memory = null; + if (module.memorySection().isPresent()) { + var memories = module.memorySection().get(); + if (memories.memoryCount() > 0) { + var defaultLimits = memories.getMemory(0).limits(); + memory = + requireNonNullElse(memoryFactory, ByteBufferMemory::new) + .apply(requireNonNullElse(memoryLimits, defaultLimits)); + } + } else { + if (mappedHostImports != null && mappedHostImports.memoryCount() > 0) { + if (mappedHostImports.memory(0) == null + || mappedHostImports.memory(0).memory() == null) { + throw new InvalidException( + "unknown memory, imported memory not defined, cannot run the" + + " program"); + } + memory = mappedHostImports.memory(0).memory(); + } else { + // No memory defined + } + } + + for (var e : exports.values()) { + switch (e.exportType()) { + case FUNCTION: + { + if (e.index() + >= module.functionSection().functionCount() + + mappedHostImports.functionCount()) { + throw new InvalidException("unknown function " + e.index()); + } + break; + } + case GLOBAL: + { + if (e.index() + >= module.globalSection().globalCount() + + mappedHostImports.globalCount()) { + throw new InvalidException("unknown global " + e.index()); + } + break; + } + case TABLE: + { + if (e.index() + >= module.tableSection().tableCount() + + mappedHostImports.tableCount()) { + throw new InvalidException("unknown table " + e.index()); + } + break; + } + case MEMORY: + { + var memoryCount = + module.memorySection() + .map(MemorySection::memoryCount) + .orElse(0); + if (e.index() >= memoryCount + mappedHostImports.memoryCount()) { + throw new InvalidException("unknown memory " + e); + } + break; + } + } + } + + if (machineFactory == null) { + machineFactory = InterpreterMachine::new; + } + + return new Instance( + module, + globalInitializers, + memory, + dataSegments, + functions, + types, + functionTypes, + mappedHostImports, + tables, + elements, + module.tagSection().map(TagSection::types).orElse(null), + exports, + machineFactory, + initialize, + start, + listener); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/InterpreterMachine.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/InterpreterMachine.java new file mode 100644 index 000000000..b85a6ac60 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/InterpreterMachine.java @@ -0,0 +1,3017 @@ +package com.dylibso.chicory.runtime; + +import static com.dylibso.chicory.wasm.types.ValType.sizeOf; +import static com.dylibso.chicory.wasm.types.Value.REF_NULL_VALUE; +import static java.util.Objects.requireNonNullElse; + +import com.dylibso.chicory.wasm.ChicoryException; +import com.dylibso.chicory.wasm.InvalidException; +import com.dylibso.chicory.wasm.types.AnnotatedInstruction; +import com.dylibso.chicory.wasm.types.CatchOpCode; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.Instruction; +import com.dylibso.chicory.wasm.types.OpCode; +import com.dylibso.chicory.wasm.types.ValType; +import com.dylibso.chicory.wasm.types.Value; +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.List; + +/** + * This is responsible for holding and interpreting the Wasm code. + */ +public class InterpreterMachine implements Machine { + + private enum AtomicOp { + ADD, + SUB, + AND, + OR, + XOR, + XCHG + } + + private final MStack stack; + + protected final Deque callStack; + + private final Instance instance; + + public InterpreterMachine(Instance instance) { + this.instance = instance; + stack = new MStack(); + this.callStack = new ArrayDeque<>(); + } + + @FunctionalInterface + protected interface Operands { + long get(int index); + } + + @SuppressWarnings("DoNotCallSuggester") + protected void evalDefault( + MStack stack, + Instance instance, + Deque callStack, + Instruction instruction, + Operands operands) + throws ChicoryException { + throw new RuntimeException("Machine doesn't recognize Instruction " + instruction); + } + + @Override + public long[] call(int funcId, long[] args) throws ChicoryException { + return call(stack, instance, callStack, funcId, args, null, true); + } + + protected long[] call( + MStack stack, + Instance instance, + Deque callStack, + int funcId, + long[] args, + FunctionType callType, + boolean popResults) + throws ChicoryException { + + checkInterruption(); + var typeId = instance.functionType(funcId); + var type = instance.type(typeId); + + if (callType != null) { + verifyIndirectCall(type, callType); + } + + var func = instance.function(funcId); + if (func != null) { + var stackFrame = + new StackFrame( + instance, + funcId, + args, + type.params(), + func.localTypes(), + func.instructions()); + stackFrame.pushCtrl(OpCode.CALL, 0, sizeOf(type.returns()), stack.size()); + callStack.push(stackFrame); + + try { + eval(stack, instance, callStack); + } catch (StackOverflowError e) { + throw new ChicoryException("call stack exhausted", e); + } + } else { + var stackFrame = new StackFrame(instance, funcId, args); + stackFrame.pushCtrl(OpCode.CALL, 0, sizeOf(type.returns()), stack.size()); + callStack.push(stackFrame); + + var imprt = instance.imports().function(funcId); + + try { + var results = imprt.handle().apply(instance, args); + // a host function can return null or an array of ints + // which we will push onto the stack + if (results != null) { + for (var result : results) { + stack.push(result); + } + } + } catch (WasmException e) { + THROW_REF(instance, instance.registerException(e), stack, stackFrame, callStack); + } + } + + if (!callStack.isEmpty()) { + callStack.pop(); + } + + if (!popResults) { + return null; + } + + if (type.returns().isEmpty()) { + return null; + } + if (stack.size() == 0) { + return null; + } + + var totalResults = sizeOf(type.returns()); + var results = new long[totalResults]; + for (var i = totalResults - 1; i >= 0; i--) { + results[i] = stack.pop(); + } + return results; + } + + protected Instance instance() { + return instance; + } + + protected MStack stack() { + return stack; + } + + protected void eval(MStack stack, Instance instance, Deque callStack) + throws ChicoryException { + var frame = callStack.peek(); + boolean shouldReturn = false; + + loop: + while (!frame.terminated()) { + if (shouldReturn) { + return; + } + var instruction = frame.loadCurrentInstruction(); + // LOGGER.log( + // System.Logger.Level.DEBUG, + // "func=" + // + frame.funcId + // + "@" + // + frame.pc + // + ": " + // + instruction + // + " stack=" + // + stack); + var opcode = instruction.opcode(); + Operands operands = instruction::operand; + instance.onExecution(instruction, stack); + switch (opcode) { + case UNREACHABLE: + throw new TrapException("Trapped on unreachable instruction"); + case NOP: + break; + case LOOP: + case BLOCK: + BLOCK(frame, stack, instance, instruction); + break; + case TRY_TABLE: + TRY_TABLE(frame, stack, instance, instruction, frame.currentPc()); + break; + case IF: + IF(frame, stack, instance, instruction); + break; + case ELSE: + frame.jumpTo(instruction.labelTrue()); + break; + case BR: + BR(frame, stack, instruction); + break; + case BR_IF: + BR_IF(frame, stack, instruction); + break; + case BR_TABLE: + BR_TABLE(frame, stack, instruction); + break; + case BR_ON_NULL: + BR_ON_NULL(frame, stack, instruction); + break; + case BR_ON_NON_NULL: + BR_ON_NON_NULL(frame, stack, instruction); + break; + case END: + { + var ctrlFrame = frame.popCtrl(); + StackFrame.doControlTransfer(ctrlFrame, stack); + + // if this is the last end, then we're done with + // the function + if (frame.isLastBlock()) { + break loop; + } + break; + } + case RETURN: + { + // RETURN doesn't pass through the END + var ctrlFrame = frame.popCtrlTillCall(); + StackFrame.doControlTransfer(ctrlFrame, stack); + callStack.clear(); + + shouldReturn = true; + break; + } + case RETURN_CALL: + // swap in place the current frame + frame = RETURN_CALL(stack, instance, callStack, operands, frame); + break; + case RETURN_CALL_INDIRECT: + // swap in place the current frame + frame = RETURN_CALL_INDIRECT(stack, instance, callStack, operands, frame); + break; + case RETURN_CALL_REF: + // swap in place the current frame + frame = RETURN_CALL_REF(stack, instance, callStack, frame); + break; + case THROW: + { + int tagNumber = (int) operands.get(0); + var tag = instance.tag(tagNumber); + var type = instance.type(tag.tagType().typeIdx()); + + var args = extractArgsForParams(stack, type.params()); + var exception = new WasmException(instance, tagNumber, args); + var exceptionIdx = instance.registerException(exception); + frame = THROW_REF(instance, exceptionIdx, stack, frame, callStack); + break; + } + case THROW_REF: + { + var exceptionIdx = (int) stack.pop(); + frame = THROW_REF(instance, exceptionIdx, stack, frame, callStack); + break; + } + case CALL_INDIRECT: + CALL_INDIRECT(stack, instance, callStack, operands); + break; + case DROP: + DROP(stack, operands); + break; + case SELECT: + SELECT(stack, operands); + break; + case SELECT_T: + SELECT_T(stack, operands); + break; + case LOCAL_GET: + LOCAL_GET(stack, operands, frame); + break; + case LOCAL_SET: + LOCAL_SET(stack, operands, frame); + break; + case LOCAL_TEE: + LOCAL_TEE(stack, operands, frame); + break; + case GLOBAL_GET: + GLOBAL_GET(stack, instance, operands); + break; + case GLOBAL_SET: + GLOBAL_SET(stack, instance, operands); + break; + case TABLE_GET: + TABLE_GET(stack, instance, operands); + break; + case TABLE_SET: + TABLE_SET(stack, instance, operands); + break; + // TODO signed and unsigned are the same right now + case I32_LOAD: + I32_LOAD(stack, instance, operands); + break; + case I64_LOAD: + I64_LOAD(stack, instance, operands); + break; + case F32_LOAD: + F32_LOAD(stack, instance, operands); + break; + case F64_LOAD: + F64_LOAD(stack, instance, operands); + break; + case I32_LOAD8_S: + I32_LOAD8_S(stack, instance, operands); + break; + case I64_LOAD8_S: + I64_LOAD8_S(stack, instance, operands); + break; + case I32_LOAD8_U: + I32_LOAD8_U(stack, instance, operands); + break; + case I64_LOAD8_U: + I64_LOAD8_U(stack, instance, operands); + break; + case I32_LOAD16_S: + I32_LOAD16_S(stack, instance, operands); + break; + case I64_LOAD16_S: + I64_LOAD16_S(stack, instance, operands); + break; + case I32_LOAD16_U: + I32_LOAD16_U(stack, instance, operands); + break; + case I64_LOAD16_U: + I64_LOAD16_U(stack, instance, operands); + break; + case I64_LOAD32_S: + I64_LOAD32_S(stack, instance, operands); + break; + case I64_LOAD32_U: + I64_LOAD32_U(stack, instance, operands); + break; + case I32_STORE: + I32_STORE(stack, instance, operands); + break; + case I32_STORE16: + case I64_STORE16: + I64_STORE16(stack, instance, operands); + break; + case I64_STORE: + I64_STORE(stack, instance, operands); + break; + case F32_STORE: + F32_STORE(stack, instance, operands); + break; + case F64_STORE: + F64_STORE(stack, instance, operands); + break; + case MEMORY_GROW: + MEMORY_GROW(stack, instance); + break; + case MEMORY_FILL: + MEMORY_FILL(stack, instance); + break; + case I32_STORE8: + case I64_STORE8: + I64_STORE8(stack, instance, operands); + break; + case I64_STORE32: + I64_STORE32(stack, instance, operands); + break; + case MEMORY_SIZE: + MEMORY_SIZE(stack, instance); + break; + // TODO 32bit and 64 bit operations are the same for now + case I32_CONST: + stack.push(operands.get(0)); + break; + case I64_CONST: + stack.push(operands.get(0)); + break; + case F32_CONST: + stack.push(operands.get(0)); + break; + case F64_CONST: + stack.push(operands.get(0)); + break; + case I32_EQ: + I32_EQ(stack); + break; + case I64_EQ: + I64_EQ(stack); + break; + case I32_NE: + I32_NE(stack); + break; + case I64_NE: + I64_NE(stack); + break; + case I32_EQZ: + I32_EQZ(stack); + break; + case I64_EQZ: + I64_EQZ(stack); + break; + case I32_LT_S: + I32_LT_S(stack); + break; + case I32_LT_U: + I32_LT_U(stack); + break; + case I64_LT_S: + I64_LT_S(stack); + break; + case I64_LT_U: + I64_LT_U(stack); + break; + case I32_GT_S: + I32_GT_S(stack); + break; + case I32_GT_U: + I32_GT_U(stack); + break; + case I64_GT_S: + I64_GT_S(stack); + break; + case I64_GT_U: + I64_GT_U(stack); + break; + case I32_GE_S: + I32_GE_S(stack); + break; + case I32_GE_U: + I32_GE_U(stack); + break; + case I64_GE_U: + I64_GE_U(stack); + break; + case I64_GE_S: + I64_GE_S(stack); + break; + case I32_LE_S: + I32_LE_S(stack); + break; + case I32_LE_U: + I32_LE_U(stack); + break; + case I64_LE_S: + I64_LE_S(stack); + break; + case I64_LE_U: + I64_LE_U(stack); + break; + case F32_EQ: + F32_EQ(stack); + break; + case F64_EQ: + F64_EQ(stack); + break; + case I32_CLZ: + I32_CLZ(stack); + break; + case I32_CTZ: + I32_CTZ(stack); + break; + case I32_POPCNT: + I32_POPCNT(stack); + break; + case I32_ADD: + I32_ADD(stack); + break; + case I64_ADD: + I64_ADD(stack); + break; + case I32_SUB: + I32_SUB(stack); + break; + case I64_SUB: + I64_SUB(stack); + break; + case I32_MUL: + I32_MUL(stack); + break; + case I64_MUL: + I64_MUL(stack); + break; + case I32_DIV_S: + I32_DIV_S(stack); + break; + case I32_DIV_U: + I32_DIV_U(stack); + break; + case I64_DIV_S: + I64_DIV_S(stack); + break; + case I64_DIV_U: + I64_DIV_U(stack); + break; + case I32_REM_S: + I32_REM_S(stack); + break; + case I32_REM_U: + I32_REM_U(stack); + break; + case I64_AND: + I64_AND(stack); + break; + case I64_OR: + I64_OR(stack); + break; + case I64_XOR: + I64_XOR(stack); + break; + case I64_SHL: + I64_SHL(stack); + break; + case I64_SHR_S: + I64_SHR_S(stack); + break; + case I64_SHR_U: + I64_SHR_U(stack); + break; + case I64_REM_S: + I64_REM_S(stack); + break; + case I64_REM_U: + I64_REM_U(stack); + break; + case I64_ROTL: + I64_ROTL(stack); + break; + case I64_ROTR: + I64_ROTR(stack); + break; + case I64_CLZ: + I64_CLZ(stack); + break; + case I64_CTZ: + I64_CTZ(stack); + break; + case I64_POPCNT: + I64_POPCNT(stack); + break; + case F32_NEG: + F32_NEG(stack); + break; + case F64_NEG: + F64_NEG(stack); + break; + case CALL: + CALL(operands); + break; + case CALL_REF: + CALL_REF(); + break; + case I32_AND: + I32_AND(stack); + break; + case I32_OR: + I32_OR(stack); + break; + case I32_XOR: + I32_XOR(stack); + break; + case I32_SHL: + I32_SHL(stack); + break; + case I32_SHR_S: + I32_SHR_S(stack); + break; + case I32_SHR_U: + I32_SHR_U(stack); + break; + case I32_ROTL: + I32_ROTL(stack); + break; + case I32_ROTR: + I32_ROTR(stack); + break; + case F32_ADD: + F32_ADD(stack); + break; + case F64_ADD: + F64_ADD(stack); + break; + case F32_SUB: + F32_SUB(stack); + break; + case F64_SUB: + F64_SUB(stack); + break; + case F32_MUL: + F32_MUL(stack); + break; + case F64_MUL: + F64_MUL(stack); + break; + case F32_DIV: + F32_DIV(stack); + break; + case F64_DIV: + F64_DIV(stack); + break; + case F32_MIN: + F32_MIN(stack); + break; + case F64_MIN: + F64_MIN(stack); + break; + case F32_MAX: + F32_MAX(stack); + break; + case F64_MAX: + F64_MAX(stack); + break; + case F32_SQRT: + F32_SQRT(stack); + break; + case F64_SQRT: + F64_SQRT(stack); + break; + case F32_FLOOR: + F32_FLOOR(stack); + break; + case F64_FLOOR: + F64_FLOOR(stack); + break; + case F32_CEIL: + F32_CEIL(stack); + break; + case F64_CEIL: + F64_CEIL(stack); + break; + case F32_TRUNC: + F32_TRUNC(stack); + break; + case F64_TRUNC: + F64_TRUNC(stack); + break; + case F32_NEAREST: + F32_NEAREST(stack); + break; + case F64_NEAREST: + F64_NEAREST(stack); + break; + // For the extend_* operations, note that java + // automatically does this when casting from + // smaller to larger primitives + case I32_EXTEND_8_S: + I32_EXTEND_8_S(stack); + break; + case I32_EXTEND_16_S: + I32_EXTEND_16_S(stack); + break; + case I64_EXTEND_8_S: + I64_EXTEND_8_S(stack); + break; + case I64_EXTEND_16_S: + I64_EXTEND_16_S(stack); + break; + case I64_EXTEND_32_S: + I64_EXTEND_32_S(stack); + break; + case F64_CONVERT_I64_U: + F64_CONVERT_I64_U(stack); + break; + case F64_CONVERT_I32_U: + F64_CONVERT_I32_U(stack); + break; + case F64_CONVERT_I32_S: + F64_CONVERT_I32_S(stack); + break; + case F64_PROMOTE_F32: + F64_PROMOTE_F32(stack); + break; + case F64_REINTERPRET_I64: + F64_REINTERPRET_I64(stack); + break; + case I64_TRUNC_F64_S: + I64_TRUNC_F64_S(stack); + break; + case I32_WRAP_I64: + I32_WRAP_I64(stack); + break; + case I64_EXTEND_I32_S: + I64_EXTEND_I32_S(stack); + break; + case I64_EXTEND_I32_U: + I64_EXTEND_I32_U(stack); + break; + case I32_REINTERPRET_F32: + I32_REINTERPRET_F32(stack); + break; + case I64_REINTERPRET_F64: + I64_REINTERPRET_F64(stack); + break; + case F32_REINTERPRET_I32: + F32_REINTERPRET_I32(stack); + break; + case F32_COPYSIGN: + F32_COPYSIGN(stack); + break; + case F32_ABS: + F32_ABS(stack); + break; + case F64_COPYSIGN: + F64_COPYSIGN(stack); + break; + case F64_ABS: + F64_ABS(stack); + break; + case F32_NE: + F32_NE(stack); + break; + case F64_NE: + F64_NE(stack); + break; + case F32_LT: + F32_LT(stack); + break; + case F64_LT: + F64_LT(stack); + break; + case F32_LE: + F32_LE(stack); + break; + case F64_LE: + F64_LE(stack); + break; + case F32_GE: + F32_GE(stack); + break; + case F64_GE: + F64_GE(stack); + break; + case F32_GT: + F32_GT(stack); + break; + case F64_GT: + F64_GT(stack); + break; + case F32_DEMOTE_F64: + F32_DEMOTE_F64(stack); + break; + case F32_CONVERT_I32_S: + F32_CONVERT_I32_S(stack); + break; + case I32_TRUNC_F32_S: + I32_TRUNC_F32_S(stack); + break; + case I32_TRUNC_SAT_F32_S: + I32_TRUNC_SAT_F32_S(stack); + break; + case I32_TRUNC_SAT_F32_U: + I32_TRUNC_SAT_F32_U(stack); + break; + case I32_TRUNC_SAT_F64_S: + I32_TRUNC_SAT_F64_S(stack); + break; + case I32_TRUNC_SAT_F64_U: + I32_TRUNC_SAT_F64_U(stack); + break; + case F32_CONVERT_I32_U: + F32_CONVERT_I32_U(stack); + break; + case I32_TRUNC_F32_U: + I32_TRUNC_F32_U(stack); + break; + case F32_CONVERT_I64_S: + F32_CONVERT_I64_S(stack); + break; + case F32_CONVERT_I64_U: + F32_CONVERT_I64_U(stack); + break; + case F64_CONVERT_I64_S: + F64_CONVERT_I64_S(stack); + break; + case I64_TRUNC_F32_U: + I64_TRUNC_F32_U(stack); + break; + case I64_TRUNC_F64_U: + I64_TRUNC_F64_U(stack); + break; + case I64_TRUNC_SAT_F32_S: + I64_TRUNC_SAT_F32_S(stack); + break; + case I64_TRUNC_SAT_F32_U: + I64_TRUNC_SAT_F32_U(stack); + break; + case I64_TRUNC_SAT_F64_S: + I64_TRUNC_SAT_F64_S(stack); + break; + case I64_TRUNC_SAT_F64_U: + I64_TRUNC_SAT_F64_U(stack); + break; + case I32_TRUNC_F64_S: + I32_TRUNC_F64_S(stack); + break; + case I32_TRUNC_F64_U: + I32_TRUNC_F64_U(stack); + break; + case I64_TRUNC_F32_S: + I64_TRUNC_F32_S(stack); + break; + case MEMORY_INIT: + MEMORY_INIT(stack, instance, operands); + break; + case TABLE_INIT: + TABLE_INIT(stack, instance, operands); + break; + case DATA_DROP: + DATA_DROP(instance, operands); + break; + case MEMORY_COPY: + MEMORY_COPY(stack, instance); + break; + case TABLE_COPY: + TABLE_COPY(stack, instance, operands); + break; + case TABLE_FILL: + TABLE_FILL(stack, instance, operands); + break; + case TABLE_SIZE: + TABLE_SIZE(stack, instance, operands); + break; + case TABLE_GROW: + TABLE_GROW(stack, instance, operands); + break; + case REF_FUNC: + stack.push(operands.get(0)); + break; + case REF_NULL: + REF_NULL(stack); + break; + case REF_IS_NULL: + REF_IS_NULL(stack); + break; + case REF_AS_NON_NULL: + REF_AS_NON_NULL(stack); + break; + case ELEM_DROP: + ELEM_DROP(instance, operands); + break; + // Threads proposal: + case I32_ATOMIC_LOAD: + I32_ATOMIC_LOAD(stack, instance, operands); + break; + case I64_ATOMIC_LOAD: + I64_ATOMIC_LOAD(stack, instance, operands); + break; + case I64_ATOMIC_LOAD8_U: + I64_ATOMIC_LOAD8_U(stack, instance, operands); + break; + case I32_ATOMIC_LOAD8_U: + I32_ATOMIC_LOAD8_U(stack, instance, operands); + break; + case I32_ATOMIC_LOAD16_U: + I32_ATOMIC_LOAD16_U(stack, instance, operands); + break; + case I64_ATOMIC_LOAD16_U: + I64_ATOMIC_LOAD16_U(stack, instance, operands); + break; + case I64_ATOMIC_LOAD32_U: + I64_ATOMIC_LOAD32_U(stack, instance, operands); + break; + case I32_ATOMIC_STORE: + I32_ATOMIC_STORE(stack, instance, operands); + break; + case I64_ATOMIC_STORE: + I64_ATOMIC_STORE(stack, instance, operands); + break; + case I32_ATOMIC_STORE8: + case I64_ATOMIC_STORE8: + I64_ATOMIC_STORE8(stack, instance, operands); + break; + case I32_ATOMIC_STORE16: + case I64_ATOMIC_STORE16: + I64_ATOMIC_STORE16(stack, instance, operands); + break; + case I64_ATOMIC_STORE32: + I64_ATOMIC_STORE32(stack, instance, operands); + break; + case I32_ATOMIC_RMW_ADD: + I32_ATOMIC_RMW(stack, instance, operands, AtomicOp.ADD); + break; + case I32_ATOMIC_RMW_SUB: + I32_ATOMIC_RMW(stack, instance, operands, AtomicOp.SUB); + break; + case I32_ATOMIC_RMW_AND: + I32_ATOMIC_RMW(stack, instance, operands, AtomicOp.AND); + break; + case I32_ATOMIC_RMW_OR: + I32_ATOMIC_RMW(stack, instance, operands, AtomicOp.OR); + break; + case I32_ATOMIC_RMW_XOR: + I32_ATOMIC_RMW(stack, instance, operands, AtomicOp.XOR); + break; + case I32_ATOMIC_RMW_XCHG: + I32_ATOMIC_RMW(stack, instance, operands, AtomicOp.XCHG); + break; + case I32_ATOMIC_RMW_CMPXCHG: + I32_ATOMIC_RMW_CMPXCHG(stack, instance, operands); + break; + case I64_ATOMIC_RMW_ADD: + I64_ATOMIC_RMW(stack, instance, operands, AtomicOp.ADD); + break; + case I64_ATOMIC_RMW_SUB: + I64_ATOMIC_RMW(stack, instance, operands, AtomicOp.SUB); + break; + case I64_ATOMIC_RMW_AND: + I64_ATOMIC_RMW(stack, instance, operands, AtomicOp.AND); + break; + case I64_ATOMIC_RMW_OR: + I64_ATOMIC_RMW(stack, instance, operands, AtomicOp.OR); + break; + case I64_ATOMIC_RMW_XOR: + I64_ATOMIC_RMW(stack, instance, operands, AtomicOp.XOR); + break; + case I64_ATOMIC_RMW_XCHG: + I64_ATOMIC_RMW(stack, instance, operands, AtomicOp.XCHG); + break; + case I64_ATOMIC_RMW_CMPXCHG: + I64_ATOMIC_RMW_CMPXCHG(stack, instance, operands); + break; + case I32_ATOMIC_RMW8_ADD_U: + case I64_ATOMIC_RMW8_ADD_U: + I64_ATOMIC_RMW8_U(stack, instance, operands, AtomicOp.ADD); + break; + case I32_ATOMIC_RMW8_SUB_U: + case I64_ATOMIC_RMW8_SUB_U: + I64_ATOMIC_RMW8_U(stack, instance, operands, AtomicOp.SUB); + break; + case I32_ATOMIC_RMW8_AND_U: + case I64_ATOMIC_RMW8_AND_U: + I64_ATOMIC_RMW8_U(stack, instance, operands, AtomicOp.AND); + break; + case I32_ATOMIC_RMW8_OR_U: + case I64_ATOMIC_RMW8_OR_U: + I64_ATOMIC_RMW8_U(stack, instance, operands, AtomicOp.OR); + break; + case I32_ATOMIC_RMW8_XOR_U: + case I64_ATOMIC_RMW8_XOR_U: + I64_ATOMIC_RMW8_U(stack, instance, operands, AtomicOp.XOR); + break; + case I32_ATOMIC_RMW8_XCHG_U: + case I64_ATOMIC_RMW8_XCHG_U: + I64_ATOMIC_RMW8_U(stack, instance, operands, AtomicOp.XCHG); + break; + case I32_ATOMIC_RMW8_CMPXCHG_U: + case I64_ATOMIC_RMW8_CMPXCHG_U: + I64_ATOMIC_RMW8_CMPXCHG_U(stack, instance, operands); + break; + case I32_ATOMIC_RMW16_ADD_U: + case I64_ATOMIC_RMW16_ADD_U: + I64_ATOMIC_RMW16_U(stack, instance, operands, AtomicOp.ADD); + break; + case I32_ATOMIC_RMW16_SUB_U: + case I64_ATOMIC_RMW16_SUB_U: + I64_ATOMIC_RMW16_U(stack, instance, operands, AtomicOp.SUB); + break; + case I32_ATOMIC_RMW16_AND_U: + case I64_ATOMIC_RMW16_AND_U: + I64_ATOMIC_RMW16_U(stack, instance, operands, AtomicOp.AND); + break; + case I32_ATOMIC_RMW16_OR_U: + case I64_ATOMIC_RMW16_OR_U: + I64_ATOMIC_RMW16_U(stack, instance, operands, AtomicOp.OR); + break; + case I32_ATOMIC_RMW16_XOR_U: + case I64_ATOMIC_RMW16_XOR_U: + I64_ATOMIC_RMW16_U(stack, instance, operands, AtomicOp.XOR); + break; + case I32_ATOMIC_RMW16_XCHG_U: + case I64_ATOMIC_RMW16_XCHG_U: + I64_ATOMIC_RMW16_U(stack, instance, operands, AtomicOp.XCHG); + break; + case I32_ATOMIC_RMW16_CMPXCHG_U: + case I64_ATOMIC_RMW16_CMPXCHG_U: + I64_ATOMIC_RMW16_CMPXCHG_U(stack, instance, operands); + break; + case I64_ATOMIC_RMW32_ADD_U: + I64_ATOMIC_RMW32_U(stack, instance, operands, AtomicOp.ADD); + break; + case I64_ATOMIC_RMW32_SUB_U: + I64_ATOMIC_RMW32_U(stack, instance, operands, AtomicOp.SUB); + break; + case I64_ATOMIC_RMW32_AND_U: + I64_ATOMIC_RMW32_U(stack, instance, operands, AtomicOp.AND); + break; + case I64_ATOMIC_RMW32_OR_U: + I64_ATOMIC_RMW32_U(stack, instance, operands, AtomicOp.OR); + break; + case I64_ATOMIC_RMW32_XOR_U: + I64_ATOMIC_RMW32_U(stack, instance, operands, AtomicOp.XOR); + break; + case I64_ATOMIC_RMW32_XCHG_U: + I64_ATOMIC_RMW32_U(stack, instance, operands, AtomicOp.XCHG); + break; + case I64_ATOMIC_RMW32_CMPXCHG_U: + I64_ATOMIC_RMW32_CMPXCHG_U(stack, instance, operands); + break; + case MEM_ATOMIC_WAIT32: + MEM_ATOMIC_WAIT32(stack, instance, operands); + break; + case MEM_ATOMIC_WAIT64: + MEM_ATOMIC_WAIT64(stack, instance, operands); + break; + case MEM_ATOMIC_NOTIFY: + MEM_ATOMIC_NOTIFY(stack, instance, operands); + break; + case ATOMIC_FENCE: + ATOMIC_FENCE(instance); + break; + default: + { + evalDefault(stack, instance, callStack, instruction, operands); + break; + } + } + } + } + + private static void I32_GE_U(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_GE_U(a, b)); + } + + private static void I64_GT_U(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_GT_U(a, b)); + } + + private static void I32_GE_S(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_GE_S(a, b)); + } + + private static void I64_GE_U(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_GE_U(a, b)); + } + + private static void I64_GE_S(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_GE_S(a, b)); + } + + private static void I32_LE_S(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_LE_S(a, b)); + } + + private static void I32_LE_U(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_LE_U(a, b)); + } + + private static void I64_LE_S(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_LE_S(a, b)); + } + + private static void I64_LE_U(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_LE_U(a, b)); + } + + private static void F32_EQ(MStack stack) { + var b = Value.longToFloat(stack.pop()); + var a = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.F32_EQ(a, b)); + } + + private static void F64_EQ(MStack stack) { + var b = Value.longToDouble(stack.pop()); + var a = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.F64_EQ(a, b)); + } + + private static void I32_CLZ(MStack stack) { + var tos = (int) stack.pop(); + stack.push(OpcodeImpl.I32_CLZ(tos)); + } + + private static void I32_CTZ(MStack stack) { + var tos = (int) stack.pop(); + stack.push(OpcodeImpl.I32_CTZ(tos)); + } + + private static void I32_POPCNT(MStack stack) { + var tos = (int) stack.pop(); + stack.push(OpcodeImpl.I32_POPCNT(tos)); + } + + private static void I32_ADD(MStack stack) { + var a = (int) stack.pop(); + var b = (int) stack.pop(); + stack.push(a + b); + } + + private static void I64_ADD(MStack stack) { + var a = stack.pop(); + var b = stack.pop(); + stack.push(a + b); + } + + private static void I32_SUB(MStack stack) { + var a = (int) stack.pop(); + var b = (int) stack.pop(); + stack.push(b - a); + } + + private static void I64_SUB(MStack stack) { + var a = stack.pop(); + var b = stack.pop(); + stack.push(b - a); + } + + private static void I32_MUL(MStack stack) { + var a = stack.pop(); + var b = stack.pop(); + stack.push(a * b); + } + + private static void I64_MUL(MStack stack) { + var a = stack.pop(); + var b = stack.pop(); + stack.push(a * b); + } + + private static void I32_DIV_S(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_DIV_S(a, b)); + } + + private static void I32_DIV_U(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_DIV_U(a, b)); + } + + private static void I64_EXTEND_8_S(MStack stack) { + var tos = stack.pop(); + stack.push(OpcodeImpl.I64_EXTEND_8_S(tos)); + } + + private static void I64_EXTEND_16_S(MStack stack) { + var tos = stack.pop(); + stack.push(OpcodeImpl.I64_EXTEND_16_S(tos)); + } + + private static void I64_EXTEND_32_S(MStack stack) { + var tos = stack.pop(); + stack.push(OpcodeImpl.I64_EXTEND_32_S(tos)); + } + + private static void F64_CONVERT_I64_U(MStack stack) { + var tos = stack.pop(); + stack.push(Value.doubleToLong(OpcodeImpl.F64_CONVERT_I64_U(tos))); + } + + private static void F64_CONVERT_I32_U(MStack stack) { + var tos = (int) stack.pop(); + stack.push(Value.doubleToLong(OpcodeImpl.F64_CONVERT_I32_U(tos))); + } + + private static void F64_CONVERT_I32_S(MStack stack) { + var tos = (int) stack.pop(); + stack.push(Value.doubleToLong(OpcodeImpl.F64_CONVERT_I32_S(tos))); + } + + private static void I32_EXTEND_8_S(MStack stack) { + var tos = (int) stack.pop(); + stack.push(OpcodeImpl.I32_EXTEND_8_S(tos)); + } + + private static void F64_NEAREST(MStack stack) { + var val = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(OpcodeImpl.F64_NEAREST(val))); + } + + private static void F32_NEAREST(MStack stack) { + var val = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(OpcodeImpl.F32_NEAREST(val))); + } + + private static void F64_TRUNC(MStack stack) { + var val = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(OpcodeImpl.F64_TRUNC(val))); + } + + private static void F64_CEIL(MStack stack) { + var val = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(OpcodeImpl.F64_CEIL(val))); + } + + private static void F32_CEIL(MStack stack) { + var val = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(OpcodeImpl.F32_CEIL(val))); + } + + private static void F64_FLOOR(MStack stack) { + var val = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(OpcodeImpl.F64_FLOOR(val))); + } + + private static void F32_FLOOR(MStack stack) { + var val = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(OpcodeImpl.F32_FLOOR(val))); + } + + private static void F64_SQRT(MStack stack) { + var val = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(OpcodeImpl.F64_SQRT(val))); + } + + private static void F32_SQRT(MStack stack) { + var val = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(OpcodeImpl.F32_SQRT(val))); + } + + private static void F64_MAX(MStack stack) { + var a = Value.longToDouble(stack.pop()); + var b = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(OpcodeImpl.F64_MAX(a, b))); + } + + private static void F32_MAX(MStack stack) { + var a = Value.longToFloat(stack.pop()); + var b = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(OpcodeImpl.F32_MAX(a, b))); + } + + private static void F64_MIN(MStack stack) { + var a = Value.longToDouble(stack.pop()); + var b = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(OpcodeImpl.F64_MIN(a, b))); + } + + private static void F32_MIN(MStack stack) { + var a = Value.longToFloat(stack.pop()); + var b = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(OpcodeImpl.F32_MIN(a, b))); + } + + private static void F64_DIV(MStack stack) { + var a = Value.longToDouble(stack.pop()); + var b = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(b / a)); + } + + private static void F32_DIV(MStack stack) { + var a = Value.longToFloat(stack.pop()); + var b = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(b / a)); + } + + private static void F64_MUL(MStack stack) { + var a = Value.longToDouble(stack.pop()); + var b = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(b * a)); + } + + private static void F32_MUL(MStack stack) { + var a = Value.longToFloat(stack.pop()); + var b = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(b * a)); + } + + private static void F64_SUB(MStack stack) { + var a = Value.longToDouble(stack.pop()); + var b = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(b - a)); + } + + private static void F32_SUB(MStack stack) { + var a = Value.longToFloat(stack.pop()); + var b = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(b - a)); + } + + private static void F64_ADD(MStack stack) { + var a = Value.longToDouble(stack.pop()); + var b = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(a + b)); + } + + private static void F32_ADD(MStack stack) { + var a = Value.longToFloat(stack.pop()); + var b = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(a + b)); + } + + private static void I32_ROTR(MStack stack) { + var c = (int) stack.pop(); + var v = (int) stack.pop(); + stack.push(OpcodeImpl.I32_ROTR(v, c)); + } + + private static void I32_ROTL(MStack stack) { + var c = (int) stack.pop(); + var v = (int) stack.pop(); + stack.push(OpcodeImpl.I32_ROTL(v, c)); + } + + private static void I32_SHR_U(MStack stack) { + var c = (int) stack.pop(); + var v = (int) stack.pop(); + stack.push(v >>> c); + } + + private static void I32_SHR_S(MStack stack) { + var c = (int) stack.pop(); + var v = (int) stack.pop(); + stack.push(v >> c); + } + + private static void I32_SHL(MStack stack) { + var c = (int) stack.pop(); + var v = (int) stack.pop(); + stack.push(v << c); + } + + private static void I32_XOR(MStack stack) { + var a = (int) stack.pop(); + var b = (int) stack.pop(); + stack.push(a ^ b); + } + + private static void I32_OR(MStack stack) { + var a = (int) stack.pop(); + var b = (int) stack.pop(); + stack.push(a | b); + } + + private static void I32_AND(MStack stack) { + var a = (int) stack.pop(); + var b = (int) stack.pop(); + stack.push(a & b); + } + + private static void I64_POPCNT(MStack stack) { + var tos = stack.pop(); + stack.push(OpcodeImpl.I64_POPCNT(tos)); + } + + private static void I64_CTZ(MStack stack) { + var tos = stack.pop(); + stack.push(OpcodeImpl.I64_CTZ(tos)); + } + + private static void I64_CLZ(MStack stack) { + var tos = stack.pop(); + stack.push(OpcodeImpl.I64_CLZ(tos)); + } + + private static void I64_ROTR(MStack stack) { + var c = stack.pop(); + var v = stack.pop(); + stack.push(OpcodeImpl.I64_ROTR(v, c)); + } + + private static void I64_ROTL(MStack stack) { + var c = stack.pop(); + var v = stack.pop(); + stack.push(OpcodeImpl.I64_ROTL(v, c)); + } + + private static void I64_REM_U(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_REM_U(a, b)); + } + + private static void I64_REM_S(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_REM_S(a, b)); + } + + private static void I64_SHR_U(MStack stack) { + var c = stack.pop(); + var v = stack.pop(); + stack.push(v >>> c); + } + + private static void I64_SHR_S(MStack stack) { + var c = stack.pop(); + var v = stack.pop(); + stack.push(v >> c); + } + + private static void I64_SHL(MStack stack) { + var c = stack.pop(); + var v = stack.pop(); + stack.push(v << c); + } + + private static void I64_XOR(MStack stack) { + var a = stack.pop(); + var b = stack.pop(); + stack.push(a ^ b); + } + + private static void I64_OR(MStack stack) { + var a = stack.pop(); + var b = stack.pop(); + stack.push(a | b); + } + + private static void I64_AND(MStack stack) { + var a = stack.pop(); + var b = stack.pop(); + stack.push(a & b); + } + + private static void I32_REM_U(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_REM_U(a, b)); + } + + private static void I32_REM_S(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_REM_S(a, b)); + } + + private static void I64_DIV_U(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_DIV_U(a, b)); + } + + private static void I64_DIV_S(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_DIV_S(a, b)); + } + + private static void I64_GT_S(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_GT_S(a, b)); + } + + private static void I32_GT_U(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_GT_U(a, b)); + } + + private static void I32_GT_S(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_GT_S(a, b)); + } + + private static void I64_LT_U(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_LT_U(a, b)); + } + + private static void I64_LT_S(MStack stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(OpcodeImpl.I64_LT_S(a, b)); + } + + private static void I32_LT_U(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_LT_U(a, b)); + } + + private static void I32_LT_S(MStack stack) { + var b = (int) stack.pop(); + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_LT_S(a, b)); + } + + private static void I64_EQZ(MStack stack) { + var a = stack.pop(); + stack.push(OpcodeImpl.I64_EQZ(a)); + } + + private static void I32_EQZ(MStack stack) { + var a = (int) stack.pop(); + stack.push(OpcodeImpl.I32_EQZ(a)); + } + + private static void I64_NE(MStack stack) { + var a = stack.pop(); + var b = stack.pop(); + stack.push(OpcodeImpl.I64_NE(a, b)); + } + + private static void I32_NE(MStack stack) { + var a = (int) stack.pop(); + var b = (int) stack.pop(); + stack.push(OpcodeImpl.I32_NE(a, b)); + } + + private static void I64_EQ(MStack stack) { + var a = stack.pop(); + var b = stack.pop(); + stack.push(OpcodeImpl.I64_EQ(a, b)); + } + + private static void I32_EQ(MStack stack) { + var a = (int) stack.pop(); + var b = (int) stack.pop(); + stack.push(OpcodeImpl.I32_EQ(a, b)); + } + + private static void MEMORY_SIZE(MStack stack, Instance instance) { + var sz = instance.memory().pages(); + stack.push(sz); + } + + private static void I64_STORE32(MStack stack, Instance instance, Operands operands) { + var value = stack.pop(); + var ptr = (int) (operands.get(1) + (int) stack.pop()); + instance.memory().writeI32(ptr, (int) value); + } + + private static void I64_STORE8(MStack stack, Instance instance, Operands operands) { + var value = (byte) stack.pop(); + var ptr = (int) (operands.get(1) + (int) stack.pop()); + instance.memory().writeByte(ptr, value); + } + + private static void F64_PROMOTE_F32(MStack stack) { + var tos = stack.pop(); + stack.push(Double.doubleToRawLongBits(Float.intBitsToFloat((int) tos))); + } + + private static void F64_REINTERPRET_I64(MStack stack) { + long tos = stack.pop(); + stack.push(Value.doubleToLong(OpcodeImpl.F64_REINTERPRET_I64(tos))); + } + + private static void I32_WRAP_I64(MStack stack) { + int tos = (int) stack.pop(); + stack.push(tos); + } + + private static void I64_EXTEND_I32_S(MStack stack) { + int tos = (int) stack.pop(); + stack.push(tos); + } + + private static void I64_EXTEND_I32_U(MStack stack) { + var tos = stack.pop(); + stack.push(OpcodeImpl.I64_EXTEND_I32_U((int) tos)); + } + + private static void I32_REINTERPRET_F32(MStack stack) { + float tos = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.I32_REINTERPRET_F32(tos)); + } + + private static void I64_REINTERPRET_F64(MStack stack) { + double tos = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.I64_REINTERPRET_F64(tos)); + } + + private static void F32_REINTERPRET_I32(MStack stack) { + int tos = (int) stack.pop(); + stack.push(Value.floatToLong(OpcodeImpl.F32_REINTERPRET_I32(tos))); + } + + private static void F32_DEMOTE_F64(MStack stack) { + var val = Value.longToDouble(stack.pop()); + + stack.push(Value.floatToLong((float) val)); + } + + private static void F32_CONVERT_I32_S(MStack stack) { + var tos = (int) stack.pop(); + stack.push(Value.floatToLong(OpcodeImpl.F32_CONVERT_I32_S(tos))); + } + + private static void I32_EXTEND_16_S(MStack stack) { + var tos = (int) stack.pop(); + stack.push(OpcodeImpl.I32_EXTEND_16_S(tos)); + } + + private static void I64_TRUNC_F64_S(MStack stack) { + double tos = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.I64_TRUNC_F64_S(tos)); + } + + private static void F32_COPYSIGN(MStack stack) { + var b = Value.longToFloat(stack.pop()); + var a = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(OpcodeImpl.F32_COPYSIGN(a, b))); + } + + private static void F32_ABS(MStack stack) { + var val = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(OpcodeImpl.F32_ABS(val))); + } + + private static void F64_ABS(MStack stack) { + var val = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(OpcodeImpl.F64_ABS(val))); + } + + private static void F32_NE(MStack stack) { + var b = Value.longToFloat(stack.pop()); + var a = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.F32_NE(a, b)); + } + + private static void F64_NE(MStack stack) { + var b = Value.longToDouble(stack.pop()); + var a = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.F64_NE(a, b)); + } + + private static void F32_LT(MStack stack) { + var b = Value.longToFloat(stack.pop()); + var a = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.F32_LT(a, b)); + } + + private static void F64_LT(MStack stack) { + var b = Value.longToDouble(stack.pop()); + var a = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.F64_LT(a, b)); + } + + private static void F32_LE(MStack stack) { + var b = Value.longToFloat(stack.pop()); + var a = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.F32_LE(a, b)); + } + + private static void F64_LE(MStack stack) { + var b = Value.longToDouble(stack.pop()); + var a = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.F64_LE(a, b)); + } + + private static void F32_GE(MStack stack) { + var b = Value.longToFloat(stack.pop()); + var a = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.F32_GE(a, b)); + } + + private static void F64_GE(MStack stack) { + var b = Value.longToDouble(stack.pop()); + var a = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.F64_GE(a, b)); + } + + private static void F32_GT(MStack stack) { + var b = Value.longToFloat(stack.pop()); + var a = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.F32_GT(a, b)); + } + + private static void F64_GT(MStack stack) { + var b = Value.longToDouble(stack.pop()); + var a = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.F64_GT(a, b)); + } + + private static void F32_CONVERT_I32_U(MStack stack) { + var tos = (int) stack.pop(); + stack.push(Value.floatToLong(OpcodeImpl.F32_CONVERT_I32_U(tos))); + } + + private static void F32_CONVERT_I64_S(MStack stack) { + var tos = stack.pop(); + stack.push(Value.floatToLong(OpcodeImpl.F32_CONVERT_I64_S(tos))); + } + + private static void REF_NULL(MStack stack) { + stack.push(REF_NULL_VALUE); + } + + private static void ELEM_DROP(Instance instance, Operands operands) { + var x = (int) operands.get(0); + instance.setElement(x, null); + } + + private static void REF_IS_NULL(MStack stack) { + var val = stack.pop(); + stack.push(((val == REF_NULL_VALUE) ? Value.TRUE : Value.FALSE)); + } + + private static void REF_AS_NON_NULL(MStack stack) { + var val = stack.pop(); + if (val == REF_NULL_VALUE) { + throw new TrapException("Trapped on ref_as_non_null on null reference"); + } + stack.push(val); + } + + private static void DATA_DROP(Instance instance, Operands operands) { + var segment = (int) operands.get(0); + instance.memory().drop(segment); + } + + private static void F64_CONVERT_I64_S(MStack stack) { + var tos = stack.pop(); + stack.push(Value.doubleToLong(OpcodeImpl.F64_CONVERT_I64_S(tos))); + } + + private static void TABLE_GROW(MStack stack, Instance instance, Operands operands) { + var tableidx = (int) operands.get(0); + var table = instance.table(tableidx); + + var size = (int) stack.pop(); + var val = (int) stack.pop(); + + var res = table.grow(size, val, instance); + stack.push(res); + } + + private static void TABLE_SIZE(MStack stack, Instance instance, Operands operands) { + var tableidx = (int) operands.get(0); + var table = instance.table(tableidx); + + stack.push(table.size()); + } + + private static void TABLE_FILL(MStack stack, Instance instance, Operands operands) { + var tableidx = (int) operands.get(0); + + var size = (int) stack.pop(); + var val = (int) stack.pop(); + var offset = (int) stack.pop(); + + OpcodeImpl.TABLE_FILL(instance, tableidx, size, val, offset); + } + + private static void TABLE_COPY(MStack stack, Instance instance, Operands operands) { + var tableidxSrc = (int) operands.get(1); + var tableidxDst = (int) operands.get(0); + + var size = (int) stack.pop(); + var s = (int) stack.pop(); + var d = (int) stack.pop(); + + OpcodeImpl.TABLE_COPY(instance, tableidxSrc, tableidxDst, size, s, d); + } + + private static void MEMORY_COPY(MStack stack, Instance instance) { + var size = (int) stack.pop(); + var offset = (int) stack.pop(); + var destination = (int) stack.pop(); + instance.memory().copy(destination, offset, size); + } + + private static void TABLE_INIT(MStack stack, Instance instance, Operands operands) { + var tableidx = (int) operands.get(1); + var elementidx = (int) operands.get(0); + + var size = (int) stack.pop(); + var elemidx = (int) stack.pop(); + var offset = (int) stack.pop(); + + OpcodeImpl.TABLE_INIT(instance, tableidx, elementidx, size, elemidx, offset); + } + + private static void MEMORY_INIT(MStack stack, Instance instance, Operands operands) { + var segmentId = (int) operands.get(0); + var size = (int) stack.pop(); + var offset = (int) stack.pop(); + var destination = (int) stack.pop(); + instance.memory().initPassiveSegment(segmentId, destination, offset, size); + } + + private static void I64_TRUNC_F32_S(MStack stack) { + var tos = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.I64_TRUNC_F32_S(tos)); + } + + private static void I32_TRUNC_F64_U(MStack stack) { + double tos = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.I32_TRUNC_F64_U(tos)); + } + + private static void I32_TRUNC_F64_S(MStack stack) { + var tos = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.I32_TRUNC_F64_S(tos)); + } + + private static void I64_TRUNC_SAT_F64_U(MStack stack) { + double tos = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.I64_TRUNC_SAT_F64_U(tos)); + } + + private static void I64_TRUNC_SAT_F64_S(MStack stack) { + var tos = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.I64_TRUNC_SAT_F64_S(tos)); + } + + private static void I64_TRUNC_SAT_F32_U(MStack stack) { + var tos = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.I64_TRUNC_SAT_F32_U(tos)); + } + + private static void I64_TRUNC_SAT_F32_S(MStack stack) { + var tos = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.I64_TRUNC_SAT_F32_S(tos)); + } + + private static void I64_TRUNC_F64_U(MStack stack) { + var tos = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.I64_TRUNC_F64_U(tos)); + } + + private static void I64_TRUNC_F32_U(MStack stack) { + var tos = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.I64_TRUNC_F32_U(tos)); + } + + private static void F32_CONVERT_I64_U(MStack stack) { + var tos = stack.pop(); + stack.push(Value.floatToLong(OpcodeImpl.F32_CONVERT_I64_U(tos))); + } + + private static void I32_TRUNC_F32_U(MStack stack) { + var tos = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.I32_TRUNC_F32_U(tos)); + } + + private static void I32_TRUNC_SAT_F64_U(MStack stack) { + double tos = Double.longBitsToDouble(stack.pop()); + stack.push(OpcodeImpl.I32_TRUNC_SAT_F64_U(tos)); + } + + private static void I32_TRUNC_SAT_F64_S(MStack stack) { + var tos = Value.longToDouble(stack.pop()); + stack.push(OpcodeImpl.I32_TRUNC_SAT_F64_S(tos)); + } + + private static void I32_TRUNC_SAT_F32_U(MStack stack) { + var tos = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.I32_TRUNC_SAT_F32_U(tos)); + } + + private static void I32_TRUNC_SAT_F32_S(MStack stack) { + var tos = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.I32_TRUNC_SAT_F32_S(tos)); + } + + private static void I32_TRUNC_F32_S(MStack stack) { + float tos = Value.longToFloat(stack.pop()); + stack.push(OpcodeImpl.I32_TRUNC_F32_S(tos)); + } + + private static void F64_COPYSIGN(MStack stack) { + var b = Value.longToDouble(stack.pop()); + var a = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(OpcodeImpl.F64_COPYSIGN(a, b))); + } + + private static void F32_TRUNC(MStack stack) { + var val = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(OpcodeImpl.F32_TRUNC(val))); + } + + protected void CALL(Operands operands) { + var funcId = (int) operands.get(0); + var typeId = instance.functionType(funcId); + var type = instance.type(typeId); + // given a list of param types, let's pop those params off the stack + // and pass as args to the function call + var args = extractArgsForParams(stack, type.params()); + call(stack, instance, callStack, funcId, args, type, false); + } + + private void CALL_REF() { + int funcId = (int) stack.pop(); + if (funcId == REF_NULL_VALUE) { + throw new TrapException("Trapped on call_ref on null function reference"); + } + var typeId = instance.functionType(funcId); + var type = instance.type(typeId); + // given a list of param types, let's pop those params off the stack + // and pass as args to the function call + var args = extractArgsForParams(stack, type.params()); + call(stack, instance, callStack, funcId, args, type, false); + } + + private static void F64_NEG(MStack stack) { + var tos = Value.longToDouble(stack.pop()); + stack.push(Value.doubleToLong(-tos)); + } + + private static void F32_NEG(MStack stack) { + var tos = Value.longToFloat(stack.pop()); + stack.push(Value.floatToLong(-tos)); + } + + private static void MEMORY_FILL(MStack stack, Instance instance) { + var size = (int) stack.pop(); + var val = (byte) stack.pop(); + var offset = (int) stack.pop(); + var end = (size + offset); + instance.memory().fill(val, offset, end); + } + + private static void MEMORY_GROW(MStack stack, Instance instance) { + var size = (int) stack.pop(); + var nPages = instance.memory().grow(size); + stack.push(nPages); + } + + protected static int readMemPtr(MStack stack, Operands operands) { + int address = (int) stack.pop(); + if (operands.get(1) < 0 || operands.get(1) >= Integer.MAX_VALUE || address < 0) { + throw new WasmRuntimeException("out of bounds memory access"); + } + + return (int) (operands.get(1) + address); + } + + private static void F64_STORE(MStack stack, Instance instance, Operands operands) { + var value = Value.longToDouble(stack.pop()); + var ptr = readMemPtr(stack, operands); + instance.memory().writeF64(ptr, value); + } + + private static void F32_STORE(MStack stack, Instance instance, Operands operands) { + var value = Value.longToFloat(stack.pop()); + var ptr = readMemPtr(stack, operands); + instance.memory().writeF32(ptr, value); + } + + private static void I64_STORE(MStack stack, Instance instance, Operands operands) { + var value = stack.pop(); + var ptr = readMemPtr(stack, operands); + instance.memory().writeLong(ptr, value); + } + + private static void I64_STORE16(MStack stack, Instance instance, Operands operands) { + var value = (short) stack.pop(); + var ptr = readMemPtr(stack, operands); + instance.memory().writeShort(ptr, value); + } + + private static void I32_STORE(MStack stack, Instance instance, Operands operands) { + var value = (int) stack.pop(); + var ptr = readMemPtr(stack, operands); + instance.memory().writeI32(ptr, value); + } + + private static void I64_LOAD32_U(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + // TODO: make all the memory.readThings to return long + var val = instance.memory().readU32(ptr); + stack.push(val); + } + + private static void I64_LOAD32_S(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readI32(ptr); + stack.push(val); + } + + private static void I64_LOAD16_U(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readU16(ptr); + stack.push(val); + } + + private static void I32_LOAD16_U(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readU16(ptr); + stack.push(val); + } + + private static void I64_LOAD16_S(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readI16(ptr); + stack.push(val); + } + + private static void I32_LOAD16_S(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readI16(ptr); + stack.push(val); + } + + private static void I64_LOAD8_U(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readU8(ptr); + stack.push(val); + } + + private static void I32_LOAD8_U(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readU8(ptr); + stack.push(val); + } + + private static void I64_LOAD8_S(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readI8(ptr); + stack.push(val); + } + + private static void I32_LOAD8_S(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readI8(ptr); + stack.push(val); + } + + private static void F64_LOAD(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readF64(ptr); + stack.push(val); + } + + private static void F32_LOAD(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readF32(ptr); + stack.push(val); + } + + private static void I64_LOAD(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readI64(ptr); + stack.push(val); + } + + private static void I32_LOAD(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().readI32(ptr); + stack.push(val); + } + + private static void TABLE_SET(MStack stack, Instance instance, Operands operands) { + var idx = (int) operands.get(0); + var table = instance.table(idx); + + var value = (int) stack.pop(); + var i = (int) stack.pop(); + table.setRef(i, value, instance); + } + + private static void TABLE_GET(MStack stack, Instance instance, Operands operands) { + var idx = (int) operands.get(0); + var i = (int) stack.pop(); + stack.push(OpcodeImpl.TABLE_GET(instance, idx, i)); + } + + private static void GLOBAL_SET(MStack stack, Instance instance, Operands operands) { + var id = (int) operands.get(0); + if (!instance.global(id).getType().equals(ValType.V128)) { + var val = stack.pop(); + instance.global(id).setValue(val); + } else { + var high = stack.pop(); + var low = stack.pop(); + instance.global(id).setValueLow(low); + instance.global(id).setValueHigh(high); + } + } + + private static void GLOBAL_GET(MStack stack, Instance instance, Operands operands) { + int idx = (int) operands.get(0); + + stack.push(instance.global(idx).getValueLow()); + if (instance.global(idx).getType().equals(ValType.V128)) { + stack.push(instance.global(idx).getValueHigh()); + } + } + + private static void DROP(MStack stack, Operands operands) { + if (operands.get(0) == ValType.ID.V128) { + stack.pop(); + } + stack.pop(); + } + + private static void SELECT(MStack stack, Operands operands) { + var pred = (int) stack.pop(); + if (operands.get(0) == ValType.ID.V128) { + var b1 = stack.pop(); + var b2 = stack.pop(); + var a1 = stack.pop(); + var a2 = stack.pop(); + if (pred == 0) { + stack.push(b2); + stack.push(b1); + } else { + stack.push(a2); + stack.push(a1); + } + } else { + var b = stack.pop(); + var a = stack.pop(); + if (pred == 0) { + stack.push(b); + } else { + stack.push(a); + } + } + } + + private static void SELECT_T(MStack stack, Operands operands) { + var pred = (int) stack.pop(); + var typeId = operands.get(0); + + if (typeId == ValType.V128.id()) { + var b1 = stack.pop(); + var b2 = stack.pop(); + var a1 = stack.pop(); + var a2 = stack.pop(); + if (pred == 0) { + stack.push(b2); + stack.push(b1); + } else { + stack.push(a2); + stack.push(a1); + } + } else { + var b = stack.pop(); + var a = stack.pop(); + if (pred == 0) { + stack.push(b); + } else { + stack.push(a); + } + } + } + + private static void LOCAL_GET(MStack stack, Operands operands, StackFrame currentStackFrame) { + var idx = (int) operands.get(0); + var i = currentStackFrame.localIndexOf(idx); + if (currentStackFrame.localType(idx).equals(ValType.V128)) { + stack.push(currentStackFrame.local(i)); + stack.push(currentStackFrame.local(i + 1)); + } else { + stack.push(currentStackFrame.local(i)); + } + } + + private static void LOCAL_SET(MStack stack, Operands operands, StackFrame currentStackFrame) { + var idx = (int) operands.get(0); + var i = currentStackFrame.localIndexOf(idx); + if (currentStackFrame.localType(idx).equals(ValType.V128)) { + currentStackFrame.setLocal(i, stack.pop()); + currentStackFrame.setLocal(i + 1, stack.pop()); + } else { + currentStackFrame.setLocal(i, stack.pop()); + } + } + + private static void LOCAL_TEE(MStack stack, Operands operands, StackFrame currentStackFrame) { + // here we peek instead of pop, leaving it on the stack + var idx = (int) operands.get(0); + var i = currentStackFrame.localIndexOf(idx); + if (currentStackFrame.localType(idx).equals(ValType.V128)) { + var tmp = stack.pop(); + currentStackFrame.setLocal(i, tmp); + currentStackFrame.setLocal(i + 1, stack.peek()); + stack.push(tmp); + } else { + currentStackFrame.setLocal(i, stack.peek()); + } + } + + private static void I32_ATOMIC_LOAD(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + if (ptr % 4 != 0) { + throw new InvalidException("unaligned atomic"); + } + var val = instance.memory().atomicReadInt(ptr); + stack.push(val); + } + + private static void I64_ATOMIC_LOAD(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + if (ptr % 8 != 0) { + throw new InvalidException("unaligned atomic"); + } + var val = instance.memory().atomicReadLong(ptr); + stack.push(val); + } + + private static void I64_ATOMIC_LOAD8_U(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().atomicReadByte(ptr); + stack.push(Byte.toUnsignedLong(val)); + } + + private static void I32_ATOMIC_LOAD8_U(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + var val = instance.memory().atomicReadByte(ptr); + stack.push(Byte.toUnsignedLong(val)); + } + + private static void I32_ATOMIC_LOAD16_U(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + if (ptr % 2 != 0) { + throw new InvalidException("unaligned atomic"); + } + var val = instance.memory().atomicReadShort(ptr); + stack.push(Short.toUnsignedLong(val)); + } + + private static void I64_ATOMIC_LOAD16_U(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + if (ptr % 2 != 0) { + throw new InvalidException("unaligned atomic"); + } + var val = instance.memory().atomicReadShort(ptr); + stack.push(Short.toUnsignedLong(val)); + } + + private static void I64_ATOMIC_LOAD32_U(MStack stack, Instance instance, Operands operands) { + var ptr = readMemPtr(stack, operands); + if (ptr % 4 != 0) { + throw new InvalidException("unaligned atomic"); + } + var val = instance.memory().atomicReadInt(ptr); + stack.push(Integer.toUnsignedLong(val)); + } + + private static void I32_ATOMIC_STORE(MStack stack, Instance instance, Operands operands) { + var value = (int) stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 4 != 0) { + throw new InvalidException("unaligned atomic"); + } + instance.memory().atomicWriteInt(ptr, value); + } + + private static void I64_ATOMIC_STORE8(MStack stack, Instance instance, Operands operands) { + var value = (byte) stack.pop(); + var ptr = readMemPtr(stack, operands); + instance.memory().atomicWriteByte(ptr, value); + } + + private static void I64_ATOMIC_STORE16(MStack stack, Instance instance, Operands operands) { + var value = (short) stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 2 != 0) { + throw new InvalidException("unaligned atomic"); + } + instance.memory().atomicWriteShort(ptr, value); + } + + private static void I64_ATOMIC_STORE32(MStack stack, Instance instance, Operands operands) { + var value = stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 4 != 0) { + throw new InvalidException("unaligned atomic"); + } + instance.memory().atomicWriteInt(ptr, (int) value); + } + + private static void I64_ATOMIC_STORE(MStack stack, Instance instance, Operands operands) { + var value = stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 8 != 0) { + throw new InvalidException("unaligned atomic"); + } + instance.memory().atomicWriteLong(ptr, value); + } + + private static void I32_ATOMIC_RMW( + MStack stack, Instance instance, Operands operands, AtomicOp op) { + var operand = (int) stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 4 != 0) { + throw new InvalidException("unaligned atomic"); + } + int oldVal; + switch (op) { + case ADD: + oldVal = instance.memory().atomicAddInt(ptr, operand); + break; + case SUB: + oldVal = instance.memory().atomicAddInt(ptr, -operand); + break; + case AND: + oldVal = instance.memory().atomicAndInt(ptr, operand); + break; + case OR: + oldVal = instance.memory().atomicOrInt(ptr, operand); + break; + case XOR: + oldVal = instance.memory().atomicXorInt(ptr, operand); + break; + case XCHG: + oldVal = instance.memory().atomicXchgInt(ptr, operand); + break; + default: + throw new IllegalStateException("Unexpected atomic op: " + op); + } + stack.push(oldVal); + } + + private static void I32_ATOMIC_RMW_CMPXCHG(MStack stack, Instance instance, Operands operands) { + var replacement = (int) stack.pop(); // c3 + var expected = (int) stack.pop(); // c2 + var ptr = readMemPtr(stack, operands); // i + if (ptr % 4 != 0) { + throw new InvalidException("unaligned atomic"); + } + var oldVal = instance.memory().atomicCmpxchgInt(ptr, expected, replacement); + stack.push(oldVal); + } + + private static void I64_ATOMIC_RMW( + MStack stack, Instance instance, Operands operands, AtomicOp op) { + var operand = stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 8 != 0) { + throw new InvalidException("unaligned atomic"); + } + long oldVal; + switch (op) { + case ADD: + oldVal = instance.memory().atomicAddLong(ptr, operand); + break; + case SUB: + oldVal = instance.memory().atomicAddLong(ptr, -operand); + break; + case AND: + oldVal = instance.memory().atomicAndLong(ptr, operand); + break; + case OR: + oldVal = instance.memory().atomicOrLong(ptr, operand); + break; + case XOR: + oldVal = instance.memory().atomicXorLong(ptr, operand); + break; + case XCHG: + oldVal = instance.memory().atomicXchgLong(ptr, operand); + break; + default: + throw new IllegalStateException("Unexpected atomic op: " + op); + } + stack.push(oldVal); + } + + private static void I64_ATOMIC_RMW_CMPXCHG(MStack stack, Instance instance, Operands operands) { + var replacement = stack.pop(); + var expected = stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 8 != 0) { + throw new InvalidException("unaligned atomic"); + } + var oldVal = instance.memory().atomicCmpxchgLong(ptr, expected, replacement); + stack.push(oldVal); + } + + private static void I64_ATOMIC_RMW8_U( + MStack stack, Instance instance, Operands operands, AtomicOp op) { + var operand = (byte) stack.pop(); + var ptr = readMemPtr(stack, operands); + byte oldVal; + switch (op) { + case ADD: + oldVal = instance.memory().atomicAddByte(ptr, operand); + break; + case SUB: + oldVal = instance.memory().atomicAddByte(ptr, (byte) -operand); + break; + case AND: + oldVal = instance.memory().atomicAndByte(ptr, operand); + break; + case OR: + oldVal = instance.memory().atomicOrByte(ptr, operand); + break; + case XOR: + oldVal = instance.memory().atomicXorByte(ptr, operand); + break; + case XCHG: + oldVal = instance.memory().atomicXchgByte(ptr, operand); + break; + default: + throw new IllegalStateException("Unexpected atomic op: " + op); + } + stack.push(Byte.toUnsignedLong(oldVal)); + } + + private static void I64_ATOMIC_RMW8_CMPXCHG_U( + MStack stack, Instance instance, Operands operands) { + var replacement = (byte) stack.pop(); + var expected = (byte) stack.pop(); + var ptr = readMemPtr(stack, operands); + var oldVal = instance.memory().atomicCmpxchgByte(ptr, expected, replacement); + stack.push(Byte.toUnsignedLong(oldVal)); + } + + private static void I64_ATOMIC_RMW16_U( + MStack stack, Instance instance, Operands operands, AtomicOp op) { + var operand = (short) stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 2 != 0) { + throw new InvalidException("unaligned atomic"); + } + short oldVal; + switch (op) { + case ADD: + oldVal = instance.memory().atomicAddShort(ptr, operand); + break; + case SUB: + oldVal = instance.memory().atomicAddShort(ptr, (short) -operand); + break; + case AND: + oldVal = instance.memory().atomicAndShort(ptr, operand); + break; + case OR: + oldVal = instance.memory().atomicOrShort(ptr, operand); + break; + case XOR: + oldVal = instance.memory().atomicXorShort(ptr, operand); + break; + case XCHG: + oldVal = instance.memory().atomicXchgShort(ptr, operand); + break; + default: + throw new IllegalStateException("Unexpected atomic op: " + op); + } + stack.push(Short.toUnsignedLong(oldVal)); + } + + private static void I64_ATOMIC_RMW16_CMPXCHG_U( + MStack stack, Instance instance, Operands operands) { + var replacement = (short) stack.pop(); + var expected = (short) stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 2 != 0) { + throw new InvalidException("unaligned atomic"); + } + var oldVal = instance.memory().atomicCmpxchgShort(ptr, expected, replacement); + stack.push(Short.toUnsignedLong(oldVal)); + } + + private static void I64_ATOMIC_RMW32_U( + MStack stack, Instance instance, Operands operands, AtomicOp op) { + var operand = (int) stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 4 != 0) { + throw new InvalidException("unaligned atomic"); + } + int oldVal; + switch (op) { + case ADD: + oldVal = instance.memory().atomicAddInt(ptr, operand); + break; + case SUB: + oldVal = instance.memory().atomicAddInt(ptr, -operand); + break; + case AND: + oldVal = instance.memory().atomicAndInt(ptr, operand); + break; + case OR: + oldVal = instance.memory().atomicOrInt(ptr, operand); + break; + case XOR: + oldVal = instance.memory().atomicXorInt(ptr, operand); + break; + case XCHG: + oldVal = instance.memory().atomicXchgInt(ptr, operand); + break; + default: + throw new IllegalStateException("Unexpected atomic op: " + op); + } + stack.push(Integer.toUnsignedLong(oldVal)); + } + + private static void I64_ATOMIC_RMW32_CMPXCHG_U( + MStack stack, Instance instance, Operands operands) { + var replacement = (int) stack.pop(); + var expected = (int) stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 4 != 0) { + throw new InvalidException("unaligned atomic"); + } + var oldVal = instance.memory().atomicCmpxchgInt(ptr, expected, replacement); + stack.push(Integer.toUnsignedLong(oldVal)); + } + + private static void MEM_ATOMIC_WAIT32(MStack stack, Instance instance, Operands operands) { + long timeout = stack.pop(); + int expected = (int) stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 4 != 0) { + throw new InvalidException("unaligned atomic"); + } + var result = instance.memory().atomicWait(ptr, expected, timeout); + stack.push(result); + } + + private static void MEM_ATOMIC_WAIT64(MStack stack, Instance instance, Operands operands) { + long timeout = stack.pop(); + long expected = stack.pop(); + var ptr = readMemPtr(stack, operands); + if (ptr % 8 != 0) { + throw new InvalidException("unaligned atomic"); + } + var result = instance.memory().atomicWait(ptr, expected, timeout); + stack.push(result); + } + + private static void MEM_ATOMIC_NOTIFY(MStack stack, Instance instance, Operands operands) { + int maxThreads = (int) stack.pop(); + var ptr = readMemPtr(stack, operands); + var result = instance.memory().atomicNotify(ptr, maxThreads); + stack.push(result); + } + + private static void ATOMIC_FENCE(Instance instance) { + instance.memory().atomicFence(); + } + + private static StackFrame RETURN_CALL( + MStack stack, + Instance instance, + Deque callStack, + Operands operands, + StackFrame currentStackFrame) { + var funcId = (int) operands.get(0); + var typeId = instance.functionType(funcId); + var type = instance.type(typeId); + var func = instance.function(funcId); + var args = extractArgsForParams(stack, type.params()); + + // optimizing when the tail call happens in the same function + if (currentStackFrame.funcId() == funcId) { + var ctrlFrame = currentStackFrame.popCtrlTillCall(); + StackFrame.doControlTransfer(ctrlFrame, stack); + currentStackFrame.reset(args); + currentStackFrame.pushCtrl(ctrlFrame); + return currentStackFrame; + } else { + var fromCallStack = !callStack.isEmpty(); + var ctrlFrame = + (fromCallStack) + ? callStack.pop().popCtrlTillCall() + : currentStackFrame.popCtrlTillCall(); + StackFrame.doControlTransfer(ctrlFrame, stack); + + if (func != null) { + var newFrame = + new StackFrame( + instance, + funcId, + args, + type.params(), + func.localTypes(), + func.instructions()); + newFrame.pushCtrl(OpCode.CALL, 0, sizeOf(type.returns()), stack.size()); + if (fromCallStack) { + callStack.push(newFrame); + } + return newFrame; + } else { + var newFrame = new StackFrame(instance, funcId, args); + newFrame.pushCtrl(OpCode.CALL, 0, sizeOf(type.returns()), stack.size()); + callStack.push(newFrame); + + var imprt = instance.imports().function(funcId); + + try { + var results = imprt.handle().apply(instance, args); + // a host function can return null or an array of ints + // which we will push onto the stack + if (results != null) { + for (var result : results) { + stack.push(result); + } + } + } catch (WasmException e) { + THROW_REF(instance, instance.registerException(e), stack, newFrame, callStack); + } + if (fromCallStack) { + callStack.push(newFrame); + } + return newFrame; + } + } + } + + private static StackFrame RETURN_CALL_INDIRECT( + MStack stack, + Instance instance, + Deque callStack, + Operands operands, + StackFrame currentStackFrame) { + var tableIdx = (int) operands.get(1); + var table = instance.table(tableIdx); + + var typeId = (int) operands.get(0); + int funcTableIdx = (int) stack.pop(); + + int funcId = table.requiredRef(funcTableIdx); + var refInstance = requireNonNullElse(table.instance(funcTableIdx), instance); + var type = refInstance.type(typeId); + + var callType = refInstance.type(refInstance.functionType(funcId)); + verifyIndirectCall(callType, type); + + var refMachine = refInstance.getMachine().getClass(); + if (!refInstance.equals(instance) && !refMachine.equals(instance.getMachine().getClass())) { + throw new ChicoryException( + "Indirect tail-call to a different Machine implementation is not supported: " + + refMachine.getName()); + } + + var args = extractArgsForParams(stack, type.params()); + + // optimizing when the tail call happens in the same function + if (currentStackFrame.funcId() == funcId) { + var ctrlFrame = currentStackFrame.popCtrlTillCall(); + StackFrame.doControlTransfer(ctrlFrame, stack); + currentStackFrame.reset(args); + currentStackFrame.pushCtrl(ctrlFrame); + return currentStackFrame; + } else { + var func = instance.function(funcId); + var fromCallStack = !callStack.isEmpty(); + + if (func != null) { + var ctrlFrame = + (fromCallStack) + ? callStack.pop().popCtrlTillCall() + : currentStackFrame.popCtrlTillCall(); + StackFrame.doControlTransfer(ctrlFrame, stack); + var newFrame = + new StackFrame( + instance, + funcId, + args, + type.params(), + func.localTypes(), + func.instructions()); + newFrame.pushCtrl(OpCode.CALL, 0, sizeOf(type.returns()), stack.size()); + if (fromCallStack) { + callStack.push(newFrame); + } + return newFrame; + } else { + var newFrame = new StackFrame(instance, funcId, args); + newFrame.pushCtrl(OpCode.CALL, 0, sizeOf(type.returns()), stack.size()); + callStack.push(newFrame); + + var imprt = instance.imports().function(funcId); + + try { + var results = imprt.handle().apply(instance, args); + // a host function can return null or an array of ints + // which we will push onto the stack + if (results != null) { + for (var result : results) { + stack.push(result); + } + } + } catch (WasmException e) { + THROW_REF(instance, instance.registerException(e), stack, newFrame, callStack); + } + if (fromCallStack) { + callStack.push(newFrame); + } + return newFrame; + } + } + } + + private static StackFrame RETURN_CALL_REF( + MStack stack, + Instance instance, + Deque callStack, + StackFrame currentStackFrame) { + int funcId = (int) stack.pop(); + if (funcId == REF_NULL_VALUE) { + throw new TrapException("Trapped on call_ref on null function reference"); + } + var typeId = instance.functionType(funcId); + var type = instance.type(typeId); + var func = instance.function(funcId); + // given a list of param types, let's pop those params off the stack + // and pass as args to the function call + var args = extractArgsForParams(stack, type.params()); + + // optimizing when the tail call happens in the same function + if (currentStackFrame.funcId() == funcId) { + var ctrlFrame = currentStackFrame.popCtrlTillCall(); + StackFrame.doControlTransfer(ctrlFrame, stack); + currentStackFrame.reset(args); + currentStackFrame.pushCtrl(ctrlFrame); + return currentStackFrame; + } else { + var ctrlFrame = callStack.pop(); + StackFrame.doControlTransfer(ctrlFrame.popCtrlTillCall(), stack); + var newFrame = + new StackFrame( + instance, + funcId, + args, + type.params(), + func.localTypes(), + func.instructions()); + newFrame.pushCtrl(OpCode.CALL, 0, sizeOf(type.returns()), stack.size()); + callStack.push(newFrame); + return newFrame; + } + } + + private void CALL_INDIRECT( + MStack stack, Instance instance, Deque callStack, Operands operands) { + var tableIdx = (int) operands.get(1); + var table = instance.table(tableIdx); + + var typeId = (int) operands.get(0); + int funcTableIdx = (int) stack.pop(); + + int funcId = table.requiredRef(funcTableIdx); + var refInstance = requireNonNullElse(table.instance(funcTableIdx), instance); + var type = refInstance.type(typeId); + + // given a list of param types, let's pop those params off the stack + // and pass as args to the function call + var args = extractArgsForParams(stack, type.params()); + if (useCurrentInstanceInterpreter(instance, refInstance, funcId)) { + call(stack, instance, callStack, funcId, args, type, false); + } else { + checkInterruption(); + var callType = refInstance.type(refInstance.functionType(funcId)); + verifyIndirectCall(callType, type); + var results = refInstance.getMachine().call(funcId, args); + if (results != null) { + for (var result : results) { + stack.push(result); + } + } + } + } + + protected boolean useCurrentInstanceInterpreter( + Instance instance, Instance refInstance, int funcId) { + return refInstance.equals(instance); + } + + private static int numberOfParams(Instance instance, AnnotatedInstruction scope) { + var typeId = (int) scope.operand(0); + if (typeId == 0x40) { // epsilon + return 0; + } + if (ValType.isValid(typeId)) { + return 0; + } + return sizeOf(instance.type(typeId).params()); + } + + private static int numberOfValuesToReturn(Instance instance, AnnotatedInstruction scope) { + if (scope.opcode() == OpCode.END) { + return 0; + } + var typeId = (int) scope.operand(0); + if (typeId == 0x40) { // epsilon + return 0; + } + if (ValType.isValid(typeId)) { + if (typeId == ValType.V128.id()) { + return 2; + } else { + return 1; + } + } + return sizeOf(instance.type(typeId).returns()); + } + + protected static StackFrame THROW_REF( + Instance instance, + int exceptionIdx, + MStack stack, + StackFrame frame, + Deque callStack) { + var exception = instance.exn(exceptionIdx); + boolean found = false; + while (!found) { + while (frame.ctrlStackSize() > 0) { + var ctrlFrame = frame.popCtrl(); + if (ctrlFrame.opCode != OpCode.TRY_TABLE) { + continue; + } + + frame.jumpTo(ctrlFrame.pc); + var tryInst = frame.loadCurrentInstruction(); + + var catches = tryInst.catches(); + for (int i = 0; i < catches.size() && !found; i++) { + var currentCatch = catches.get(i); + + // verify import compatibility + var compatibleImport = false; + if ((currentCatch.opcode() == CatchOpCode.CATCH + || currentCatch.opcode() == CatchOpCode.CATCH_REF)) { + var currentCatchTag = instance.tag(currentCatch.tag()); + var exceptionTag = exception.instance().tag(exception.tagIdx()); + + // if it's an import we verify the compatibility + if (currentCatch.tag() < instance.imports().tagCount() + && currentCatchTag.type().paramsMatch(exceptionTag.type()) + && currentCatchTag.type().returnsMatch(exceptionTag.type())) { + compatibleImport = true; + } else if (exceptionTag != currentCatchTag) { + // if it's not an import the tag should be the same + continue; + } + } + + switch (currentCatch.opcode()) { + case CATCH: + if (currentCatch.tag() == exception.tagIdx() || compatibleImport) { + found = true; + for (var arg : exception.args()) { + stack.push(arg); + } + } + break; + case CATCH_REF: + if (currentCatch.tag() == exception.tagIdx() || compatibleImport) { + found = true; + for (var arg : exception.args()) { + stack.push(arg); + } + stack.push(exceptionIdx); + } + break; + case CATCH_ALL: + found = true; + break; + case CATCH_ALL_REF: + found = true; + stack.push(exceptionIdx); + break; + } + + if (found) { + // BR l + ctrlJump(frame, stack, currentCatch.label()); + frame.jumpTo(currentCatch.resolvedLabel()); + return frame; + } + } + } + if (!found) { + if (callStack.isEmpty()) { + throw exception; + } else { + frame = callStack.pop(); + } + } + } + throw new RuntimeException("unreacheable"); + } + + private static void BLOCK( + StackFrame frame, MStack stack, Instance instance, AnnotatedInstruction instruction) { + var paramsSize = numberOfParams(instance, instruction); + var returnsSize = numberOfValuesToReturn(instance, instruction); + frame.pushCtrl(instruction.opcode(), paramsSize, returnsSize, stack.size() - paramsSize); + } + + private static void TRY_TABLE( + StackFrame frame, + MStack stack, + Instance instance, + AnnotatedInstruction instruction, + int pc) { + var paramsSize = numberOfParams(instance, instruction); + var returnsSize = numberOfValuesToReturn(instance, instruction); + frame.pushCtrl( + instruction.opcode(), paramsSize, returnsSize, stack.size() - paramsSize, pc); + } + + private static void IF( + StackFrame frame, MStack stack, Instance instance, AnnotatedInstruction instruction) { + var predValue = stack.pop(); + var paramsSize = numberOfParams(instance, instruction); + var returnsSize = numberOfValuesToReturn(instance, instruction); + frame.pushCtrl(instruction.opcode(), paramsSize, returnsSize, stack.size() - paramsSize); + + frame.jumpTo(predValue == 0 ? instruction.labelFalse() : instruction.labelTrue()); + } + + private static void ctrlJump(StackFrame frame, MStack stack, int n) { + var ctrlFrame = frame.popCtrl(n); + frame.pushCtrl(ctrlFrame); + // a LOOP jumps back to the first instruction without passing through an END + if (ctrlFrame.opCode == OpCode.LOOP) { + StackFrame.doControlTransfer(ctrlFrame, stack); + } + } + + private static void BR(StackFrame frame, MStack stack, AnnotatedInstruction instruction) { + checkInterruption(); + ctrlJump(frame, stack, (int) instruction.operand(0)); + frame.jumpTo(instruction.labelTrue()); + } + + private static void BR_TABLE(StackFrame frame, MStack stack, AnnotatedInstruction instruction) { + var pred = (int) stack.pop(); + + var defaultIdx = instruction.operandCount() - 1; + if (pred < 0 || pred >= defaultIdx) { + // choose default + ctrlJump(frame, stack, (int) instruction.operand(defaultIdx)); + frame.jumpTo(instruction.labelTable().get(defaultIdx)); + } else { + ctrlJump(frame, stack, (int) instruction.operand(pred)); + frame.jumpTo(instruction.labelTable().get(pred)); + } + } + + private static void BR_IF(StackFrame frame, MStack stack, AnnotatedInstruction instruction) { + var pred = (int) stack.pop(); + + if (pred == 0) { + frame.jumpTo(instruction.labelFalse()); + } else { + ctrlJump(frame, stack, (int) instruction.operand(0)); + frame.jumpTo(instruction.labelTrue()); + } + } + + private static void BR_ON_NULL( + StackFrame frame, MStack stack, AnnotatedInstruction instruction) { + var ref = (int) stack.pop(); + if (ref == REF_NULL_VALUE) { + BR(frame, stack, instruction); + } else { + stack.push(ref); + } + } + + private static void BR_ON_NON_NULL( + StackFrame frame, MStack stack, AnnotatedInstruction instruction) { + var ref = (int) stack.pop(); + if (ref == REF_NULL_VALUE) { + // do nothing + } else { + stack.push(ref); + BR(frame, stack, instruction); + } + } + + protected static long[] extractArgsForParams(MStack stack, List params) { + if (params == null) { + return Value.EMPTY_VALUES; + } + var args = new long[sizeOf(params)]; + for (var i = 0; i < args.length; i++) { + args[args.length - i - 1] = stack.pop(); + } + return args; + } + + private static boolean functionTypeMatch(FunctionType actual, FunctionType expected) { + if (actual.params().size() != expected.params().size() + || actual.returns().size() != expected.returns().size()) { + return false; + } + + for (int i = 0; i < actual.params().size(); i++) { + var actualParam = actual.params().get(i); + var expectedParam = expected.params().get(i); + + if (!ValType.matches(actualParam, expectedParam)) { + return false; + } + } + + for (int i = 0; i < actual.returns().size(); i++) { + var actualReturn = actual.returns().get(i); + var expectedReturn = expected.returns().get(i); + + if (!ValType.matches(expectedReturn, actualReturn)) { + return false; + } + } + + return true; + } + + protected static void verifyIndirectCall(FunctionType actual, FunctionType expected) + throws ChicoryException { + if (!functionTypeMatch(actual, expected)) { + throw new ChicoryException("indirect call type mismatch"); + } + } + + /** + * Terminate WASM execution if requested. + * This is called at the start of each call and at any potentially backwards branches. + * Forward branches and other non-branch instructions are not checked, as the + * execution will run until it eventually reaches a termination point. + */ + private static void checkInterruption() { + if (Thread.currentThread().isInterrupted()) { + throw new ChicoryInterruptedException("Thread interrupted"); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/MStack.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/MStack.java new file mode 100644 index 000000000..3a16b2d7a --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/MStack.java @@ -0,0 +1,48 @@ +package com.dylibso.chicory.runtime; + +public class MStack { + public static final int MIN_CAPACITY = 8; + + private int count; + private long[] elements; + + public MStack() { + this.elements = new long[MIN_CAPACITY]; + } + + private void increaseCapacity() { + final int newCapacity = elements.length << 1; + + final long[] array = new long[newCapacity]; + System.arraycopy(elements, 0, array, 0, elements.length); + + elements = array; + } + + // internal use only! + public long[] array() { + return elements; + } + + public void push(long v) { + elements[count] = v; + count++; + + if (count == elements.length) { + increaseCapacity(); + } + } + + public long pop() { + count--; + return elements[count]; + } + + public long peek() { + return elements[count - 1]; + } + + public int size() { + return count; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Machine.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Machine.java new file mode 100644 index 000000000..b058d8537 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Machine.java @@ -0,0 +1,9 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.ChicoryException; + +@FunctionalInterface +public interface Machine { + + long[] call(int funcId, long[] args) throws ChicoryException; +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/MemCopyWorkaround.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/MemCopyWorkaround.java new file mode 100644 index 000000000..23f6c1803 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/MemCopyWorkaround.java @@ -0,0 +1,26 @@ +package com.dylibso.chicory.runtime; + +// +// This class is used by compiler generated classes. It MUST remain backwards compatible +// so that older generated code can run on newer versions of the library. +// +// This is an ugly hack to work around a bug on some JVMs (Temurin 17-) +public final class MemCopyWorkaround { + private MemCopyWorkaround() {} + + public static boolean shouldUseMemWorkaround() { + return false; + } + + public static boolean shouldUseMemWorkaround(String version) { + return false; + } + + public static void memoryCopy(int destination, int offset, int size, Memory memory) { + memory.copy(destination, offset, size); + } + + public static int i32_ge_u(int a, int b) { + return OpcodeImpl.I32_GE_U(a, b); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Memory.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Memory.java new file mode 100644 index 000000000..2841c9e8b --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Memory.java @@ -0,0 +1,427 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.types.DataSegment; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; + +public interface Memory { + + /** + * A WebAssembly page size is 64KiB = 65,536 bytes. + */ + public static final int PAGE_SIZE = 65536; + + /** + * Maximum number of pages allowed by the runtime. + * WASM supports 2^16 pages, but we must limit based on the maximum JVM array size. + * This limit is {@code Integer.MAX_VALUE / PAGE_SIZE}. + */ + public static final int RUNTIME_MAX_PAGES = 32767; + + static int bytes(int pages) { + return PAGE_SIZE * Math.min(pages, RUNTIME_MAX_PAGES); + } + + int pages(); + + int grow(int size); + + int initialPages(); + + int maximumPages(); + + boolean shared(); + + @Deprecated(forRemoval = true) + Object lock(int address); + + @Deprecated(forRemoval = true) + int waitOn(int address, int expected, long timeout); + + @Deprecated(forRemoval = true) + int waitOn(int address, long expected, long timeout); + + @Deprecated(forRemoval = true) + int notify(int address, int maxThreads); + + // Atomic operations + // All these default implementations will be converted to abstract methods in the next major + // release. + /////////////////////////// + + default void atomicFence() { + ByteBufferMemory.ATOMIC_FENCE_IMPL.run(); + } + + default int atomicWait(int addr, int expected, long timeout) { + return waitOn(addr, expected, timeout); + } + + default int atomicWait(int addr, long expected, long timeout) { + return waitOn(addr, expected, timeout); + } + + default int atomicNotify(int addr, int maxThreads) { + return notify(addr, maxThreads); + } + + default int atomicReadInt(int addr) { + synchronized (lock(addr)) { + return readInt(addr); + } + } + + default long atomicReadLong(int addr) { + synchronized (lock(addr)) { + return readLong(addr); + } + } + + default short atomicReadShort(int addr) { + synchronized (lock(addr)) { + return readShort(addr); + } + } + + default byte atomicReadByte(int addr) { + synchronized (lock(addr)) { + return read(addr); + } + } + + default void atomicWriteInt(int addr, int value) { + synchronized (lock(addr)) { + writeI32(addr, value); + } + } + + default void atomicWriteLong(int addr, long value) { + synchronized (lock(addr)) { + writeLong(addr, value); + } + } + + default void atomicWriteShort(int addr, short value) { + synchronized (lock(addr)) { + writeShort(addr, value); + } + } + + default void atomicWriteByte(int addr, byte value) { + synchronized (lock(addr)) { + writeByte(addr, value); + } + } + + default int atomicAddInt(int addr, int delta) { + synchronized (lock(addr)) { + int val = readInt(addr); + writeI32(addr, val + delta); + return val; + } + } + + default int atomicAndInt(int addr, int mask) { + synchronized (lock(addr)) { + int val = readInt(addr); + writeI32(addr, val & mask); + return val; + } + } + + default int atomicOrInt(int addr, int mask) { + synchronized (lock(addr)) { + int val = readInt(addr); + writeI32(addr, val | mask); + return val; + } + } + + default int atomicXorInt(int addr, int mask) { + synchronized (lock(addr)) { + int val = readInt(addr); + writeI32(addr, val ^ mask); + return val; + } + } + + default int atomicXchgInt(int addr, int value) { + synchronized (lock(addr)) { + int val = readInt(addr); + writeI32(addr, value); + return val; + } + } + + default int atomicCmpxchgInt(int addr, int expected, int replacement) { + synchronized (lock(addr)) { + int val = readInt(addr); + if (val == expected) { + writeI32(addr, replacement); + } + return val; + } + } + + default long atomicAddLong(int addr, long delta) { + synchronized (lock(addr)) { + long val = readLong(addr); + writeLong(addr, val + delta); + return val; + } + } + + default long atomicAndLong(int addr, long mask) { + synchronized (lock(addr)) { + long val = readLong(addr); + writeLong(addr, val & mask); + return val; + } + } + + default long atomicOrLong(int addr, long mask) { + synchronized (lock(addr)) { + long val = readLong(addr); + writeLong(addr, val | mask); + return val; + } + } + + default long atomicXorLong(int addr, long mask) { + synchronized (lock(addr)) { + long val = readLong(addr); + writeLong(addr, val ^ mask); + return val; + } + } + + default long atomicXchgLong(int addr, long value) { + synchronized (lock(addr)) { + long val = readLong(addr); + writeLong(addr, value); + return val; + } + } + + default long atomicCmpxchgLong(int addr, long expected, long replacement) { + synchronized (lock(addr)) { + long val = readLong(addr); + if (val == expected) { + writeLong(addr, replacement); + } + return val; + } + } + + default short atomicAddShort(int addr, short delta) { + synchronized (lock(addr)) { + short val = readShort(addr); + writeShort(addr, (short) (val + delta)); + return val; + } + } + + default short atomicAndShort(int addr, short mask) { + synchronized (lock(addr)) { + short val = readShort(addr); + writeShort(addr, (short) (val & mask)); + return val; + } + } + + default short atomicOrShort(int addr, short mask) { + synchronized (lock(addr)) { + short val = readShort(addr); + writeShort(addr, (short) (val | mask)); + return val; + } + } + + default short atomicXorShort(int addr, short mask) { + synchronized (lock(addr)) { + short val = readShort(addr); + writeShort(addr, (short) (val ^ mask)); + return val; + } + } + + default short atomicXchgShort(int addr, short value) { + synchronized (lock(addr)) { + short val = readShort(addr); + writeShort(addr, value); + return val; + } + } + + default short atomicCmpxchgShort(int addr, short expected, short replacement) { + synchronized (lock(addr)) { + short val = readShort(addr); + if (val == expected) { + writeShort(addr, replacement); + } + return val; + } + } + + default byte atomicAddByte(int addr, byte delta) { + synchronized (lock(addr)) { + byte val = read(addr); + writeByte(addr, (byte) (val + delta)); + return val; + } + } + + default byte atomicAndByte(int addr, byte mask) { + synchronized (lock(addr)) { + byte val = read(addr); + writeByte(addr, (byte) (val & mask)); + return val; + } + } + + default byte atomicOrByte(int addr, byte mask) { + synchronized (lock(addr)) { + byte val = read(addr); + writeByte(addr, (byte) (val | mask)); + return val; + } + } + + default byte atomicXorByte(int addr, byte mask) { + synchronized (lock(addr)) { + byte val = read(addr); + writeByte(addr, (byte) (val ^ mask)); + return val; + } + } + + default byte atomicXchgByte(int addr, byte value) { + synchronized (lock(addr)) { + byte val = read(addr); + writeByte(addr, value); + return val; + } + } + + default byte atomicCmpxchgByte(int addr, byte expected, byte replacement) { + synchronized (lock(addr)) { + byte val = read(addr); + if (val == expected) { + writeByte(addr, replacement); + } + return val; + } + } + + void initialize(Instance instance, DataSegment[] dataSegments); + + void initPassiveSegment(int segmentId, int dest, int offset, int size); + + default void writeString(int offset, String data, Charset charSet) { + write(offset, data.getBytes(charSet)); + } + + default void writeString(int offset, String data) { + writeString(offset, data, StandardCharsets.UTF_8); + } + + default String readString(int addr, int len) { + return readString(addr, len, StandardCharsets.UTF_8); + } + + default String readString(int addr, int len, Charset charSet) { + return new String(readBytes(addr, len), charSet); + } + + default void writeCString(int offset, String str) { + writeCString(offset, str, StandardCharsets.UTF_8); + } + + default void writeCString(int offset, String str, Charset charSet) { + writeString(offset, str + '\0', charSet); + } + + default String readCString(int addr, Charset charSet) { + int c = addr; + while (read(c) != '\0') { + c++; + } + return new String(readBytes(addr, c - addr), charSet); + } + + default String readCString(int addr) { + return readCString(addr, StandardCharsets.UTF_8); + } + + default void write(int addr, byte[] data) { + write(addr, data, 0, data.length); + } + + void write(int addr, byte[] data, int offset, int size); + + byte read(int addr); + + byte[] readBytes(int addr, int len); + + void writeI32(int addr, int data); + + int readInt(int addr); + + default long readI32(int addr) { + return readInt(addr); + } + + default long readU32(int addr) { + return Integer.toUnsignedLong(readInt(addr)); + } + + void writeLong(int addr, long data); + + long readLong(int addr); + + default long readI64(int addr) { + return readLong(addr); + } + + void writeShort(int addr, short data); + + short readShort(int addr); + + default long readI16(int addr) { + return readShort(addr); + } + + long readU16(int addr); + + void writeByte(int addr, byte data); + + default long readU8(int addr) { + return read(addr) & 0xFF; + } + + default long readI8(int addr) { + return read(addr); + } + + void writeF32(int addr, float data); + + long readF32(int addr); + + float readFloat(int addr); + + void writeF64(int addr, double data); + + double readDouble(int addr); + + long readF64(int addr); + + void zero(); + + void fill(byte value, int fromIndex, int toIndex); + + default void copy(int dest, int src, int size) { + write(dest, readBytes(src, size)); + } + + void drop(int segment); +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/OpCodeIdentifier.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/OpCodeIdentifier.java new file mode 100644 index 000000000..e313a97e3 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/OpCodeIdentifier.java @@ -0,0 +1,14 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.types.OpCode; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.METHOD) +public @interface OpCodeIdentifier { + + OpCode value(); +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/OpcodeImpl.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/OpcodeImpl.java new file mode 100644 index 000000000..50028aabc --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/OpcodeImpl.java @@ -0,0 +1,870 @@ +package com.dylibso.chicory.runtime; + +import static com.dylibso.chicory.runtime.BitOps.FALSE; +import static com.dylibso.chicory.runtime.BitOps.TRUE; +import static com.dylibso.chicory.runtime.ConstantEvaluators.computeConstantValue; + +import com.dylibso.chicory.wasm.types.OpCode; +import com.dylibso.chicory.wasm.types.PassiveElement; +import com.dylibso.chicory.wasm.types.ValType; + +/** + * Note: Some opcodes are easy or trivial to implement as compiler intrinsics (local.get, i32.add, etc). + * Others would be very difficult to implement and maintain (floating point truncations, for example). + * The idea of this class is to share the core logic of both the interpreter and AOT implementations for + * shareable opcodes (that is, opcodes that are not completely different in operation depending on + * whether they're run in the interpreter or in the AOT, such as local.get, local.set, etc) in a + * single place that is statically accessible. If the AOT does not have an intrinsic for an opcode (and + * the opcode is not a flow control opcode), then a static call will be generated to the method in this + * class that implements the opcode. + *

+ * Note about parameter ordering: because of the JVM's calling convention, the parameters to a method + * are ordered such that the last value pushed is the last argument to the method, i.e., + * method(tos - 2, tos - 1, tos). + */ +public final class OpcodeImpl { + + private OpcodeImpl() {} + + // ========= I32 ========= + + @OpCodeIdentifier(OpCode.I32_CLZ) + public static int I32_CLZ(int tos) { + return Integer.numberOfLeadingZeros(tos); + } + + @OpCodeIdentifier(OpCode.I32_CTZ) + public static int I32_CTZ(int tos) { + return Integer.numberOfTrailingZeros(tos); + } + + @OpCodeIdentifier(OpCode.I32_DIV_S) + public static int I32_DIV_S(int a, int b) { + if (a == Integer.MIN_VALUE && b == -1) { + throw new WasmRuntimeException("integer overflow"); + } + if (b == 0) { + throw new WasmRuntimeException("integer divide by zero"); + } + return a / b; + } + + @OpCodeIdentifier(OpCode.I32_DIV_U) + public static int I32_DIV_U(int a, int b) { + if (b == 0) { + throw new WasmRuntimeException("integer divide by zero"); + } + return Integer.divideUnsigned(a, b); + } + + @OpCodeIdentifier(OpCode.I32_EQ) + public static int I32_EQ(int b, int a) { + return a == b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I32_EQZ) + public static int I32_EQZ(int a) { + return a == 0 ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I32_EXTEND_8_S) + public static int I32_EXTEND_8_S(int tos) { + return (byte) tos; + } + + @OpCodeIdentifier(OpCode.I32_EXTEND_16_S) + public static int I32_EXTEND_16_S(int tos) { + return (short) tos; + } + + @OpCodeIdentifier(OpCode.I32_GE_S) + public static int I32_GE_S(int a, int b) { + return a >= b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I32_GE_U) + public static int I32_GE_U(int a, int b) { + return Integer.compareUnsigned(a, b) >= 0 ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I32_GT_S) + public static int I32_GT_S(int a, int b) { + return a > b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I32_GT_U) + public static int I32_GT_U(int a, int b) { + return Integer.compareUnsigned(a, b) > 0 ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I32_LE_S) + public static int I32_LE_S(int a, int b) { + return a <= b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I32_LE_U) + public static int I32_LE_U(int a, int b) { + return Integer.compareUnsigned(a, b) <= 0 ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I32_LT_S) + public static int I32_LT_S(int a, int b) { + return a < b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I32_LT_U) + public static int I32_LT_U(int a, int b) { + return Integer.compareUnsigned(a, b) < 0 ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I32_NE) + public static int I32_NE(int b, int a) { + return a == b ? FALSE : TRUE; + } + + @OpCodeIdentifier(OpCode.I32_POPCNT) + public static int I32_POPCNT(int tos) { + return Integer.bitCount(tos); + } + + @OpCodeIdentifier(OpCode.I32_REINTERPRET_F32) + public static int I32_REINTERPRET_F32(float x) { + return Float.floatToRawIntBits(x); + } + + @OpCodeIdentifier(OpCode.I32_REM_S) + public static int I32_REM_S(int a, int b) { + if (b == 0) { + throw new WasmRuntimeException("integer divide by zero"); + } + return a % b; + } + + @OpCodeIdentifier(OpCode.I32_REM_U) + public static int I32_REM_U(int a, int b) { + if (b == 0) { + throw new WasmRuntimeException("integer divide by zero"); + } + return Integer.remainderUnsigned(a, b); + } + + @OpCodeIdentifier(OpCode.I32_ROTR) + public static int I32_ROTR(int v, int c) { + return (v >>> c) | (v << (32 - c)); + } + + @OpCodeIdentifier(OpCode.I32_ROTL) + public static int I32_ROTL(int v, int c) { + return (v << c) | (v >>> (32 - c)); + } + + @OpCodeIdentifier(OpCode.I32_TRUNC_F32_S) + public static int I32_TRUNC_F32_S(float x) { + if (Float.isNaN(x)) { + throw new WasmRuntimeException("invalid conversion to integer"); + } + if (x < Integer.MIN_VALUE || x >= Integer.MAX_VALUE) { + throw new WasmRuntimeException("integer overflow"); + } + return (int) x; + } + + @OpCodeIdentifier(OpCode.I32_TRUNC_F32_U) + public static int I32_TRUNC_F32_U(float x) { + if (Float.isNaN(x)) { + throw new WasmRuntimeException("invalid conversion to integer"); + } + long v = (long) x; + if (v < 0 || v >= 0xFFFFFFFFL) { + throw new WasmRuntimeException("integer overflow"); + } + return (int) v; + } + + @OpCodeIdentifier(OpCode.I32_TRUNC_F64_S) + public static int I32_TRUNC_F64_S(double tos) { + if (Double.isNaN(tos)) { + throw new WasmRuntimeException("invalid conversion to integer"); + } + var v = (long) tos; + if (v < Integer.MIN_VALUE || v > Integer.MAX_VALUE) { + throw new WasmRuntimeException("integer overflow"); + } + return (int) v; + } + + @OpCodeIdentifier(OpCode.I32_TRUNC_F64_U) + public static int I32_TRUNC_F64_U(double tos) { + if (Double.isNaN(tos)) { + throw new WasmRuntimeException("invalid conversion to integer"); + } + var v = (long) tos; + if (v < 0 || v > 0xFFFFFFFFL) { + throw new WasmRuntimeException("integer overflow"); + } + return (int) v; + } + + @OpCodeIdentifier(OpCode.I32_TRUNC_SAT_F32_S) + public static int I32_TRUNC_SAT_F32_S(float x) { + if (Float.isNaN(x)) { + return 0; + } + if (x < Integer.MIN_VALUE) { + return Integer.MIN_VALUE; + } + if (x > Integer.MAX_VALUE) { + return Integer.MAX_VALUE; + } + return (int) x; + } + + @OpCodeIdentifier(OpCode.I32_TRUNC_SAT_F32_U) + public static int I32_TRUNC_SAT_F32_U(float x) { + if (Float.isNaN(x) || x < 0) { + return 0; + } + if (x >= 0xFFFFFFFFL) { + return 0xFFFFFFFF; + } + return (int) (long) x; + } + + @OpCodeIdentifier(OpCode.I32_TRUNC_SAT_F64_S) + public static int I32_TRUNC_SAT_F64_S(double x) { + if (Double.isNaN(x)) { + return 0; + } + if (x < Integer.MIN_VALUE) { + return Integer.MIN_VALUE; + } + if (x > Integer.MAX_VALUE) { + return Integer.MAX_VALUE; + } + return (int) x; + } + + @OpCodeIdentifier(OpCode.I32_TRUNC_SAT_F64_U) + public static int I32_TRUNC_SAT_F64_U(double x) { + if (Double.isNaN(x) || x < 0) { + return 0; + } + if (x > 0xFFFFFFFFL) { + return 0xFFFFFFFF; + } + return (int) (long) x; + } + + // ========= I64 ========= + + @OpCodeIdentifier(OpCode.I64_CLZ) + public static long I64_CLZ(long tos) { + return Long.numberOfLeadingZeros(tos); + } + + @OpCodeIdentifier(OpCode.I64_CTZ) + public static long I64_CTZ(long tos) { + return Long.numberOfTrailingZeros(tos); + } + + @OpCodeIdentifier(OpCode.I64_DIV_S) + public static long I64_DIV_S(long a, long b) { + if (a == Long.MIN_VALUE && b == -1) { + throw new WasmRuntimeException("integer overflow"); + } + if (b == 0L) { + throw new WasmRuntimeException("integer divide by zero"); + } + return a / b; + } + + @OpCodeIdentifier(OpCode.I64_DIV_U) + public static long I64_DIV_U(long a, long b) { + if (b == 0L) { + throw new WasmRuntimeException("integer divide by zero"); + } + return Long.divideUnsigned(a, b); + } + + @OpCodeIdentifier(OpCode.I64_EQ) + public static int I64_EQ(long b, long a) { + return a == b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I64_EQZ) + public static int I64_EQZ(long a) { + return a == 0 ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I64_EXTEND_8_S) + public static long I64_EXTEND_8_S(long tos) { + return (byte) tos; + } + + @OpCodeIdentifier(OpCode.I64_EXTEND_16_S) + public static long I64_EXTEND_16_S(long tos) { + return (short) tos; + } + + @OpCodeIdentifier(OpCode.I64_EXTEND_32_S) + public static long I64_EXTEND_32_S(long tos) { + return (int) tos; + } + + @OpCodeIdentifier(OpCode.I64_EXTEND_I32_U) + public static long I64_EXTEND_I32_U(int x) { + return Integer.toUnsignedLong(x); + } + + @OpCodeIdentifier(OpCode.I64_GE_S) + public static int I64_GE_S(long a, long b) { + return a >= b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I64_GE_U) + public static int I64_GE_U(long a, long b) { + return Long.compareUnsigned(a, b) >= 0 ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I64_GT_S) + public static int I64_GT_S(long a, long b) { + return a > b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I64_GT_U) + public static int I64_GT_U(long a, long b) { + return Long.compareUnsigned(a, b) > 0 ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I64_LE_S) + public static int I64_LE_S(long a, long b) { + return a <= b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I64_LE_U) + public static int I64_LE_U(long a, long b) { + return Long.compareUnsigned(a, b) <= 0 ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I64_LT_S) + public static int I64_LT_S(long a, long b) { + return a < b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I64_LT_U) + public static int I64_LT_U(long a, long b) { + return Long.compareUnsigned(a, b) < 0 ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.I64_NE) + public static int I64_NE(long b, long a) { + return a == b ? FALSE : TRUE; + } + + @OpCodeIdentifier(OpCode.I64_POPCNT) + public static long I64_POPCNT(long tos) { + return Long.bitCount(tos); + } + + @OpCodeIdentifier(OpCode.I64_REINTERPRET_F64) + public static long I64_REINTERPRET_F64(double x) { + return Double.doubleToRawLongBits(x); + } + + @OpCodeIdentifier(OpCode.I64_REM_S) + public static long I64_REM_S(long a, long b) { + if (b == 0L) { + throw new WasmRuntimeException("integer divide by zero"); + } + return a % b; + } + + @OpCodeIdentifier(OpCode.I64_REM_U) + public static long I64_REM_U(long a, long b) { + if (b == 0L) { + throw new WasmRuntimeException("integer divide by zero"); + } + return Long.remainderUnsigned(a, b); + } + + @OpCodeIdentifier(OpCode.I64_ROTR) + public static long I64_ROTR(long v, long c) { + return (v >>> c) | (v << (64 - c)); + } + + @OpCodeIdentifier(OpCode.I64_ROTL) + public static long I64_ROTL(long v, long c) { + return (v << c) | (v >>> (64 - c)); + } + + @OpCodeIdentifier(OpCode.I64_TRUNC_F32_S) + public static long I64_TRUNC_F32_S(float x) { + if (Float.isNaN(x)) { + throw new WasmRuntimeException("invalid conversion to integer"); + } + if (x < Long.MIN_VALUE || x >= Long.MAX_VALUE) { + throw new WasmRuntimeException("integer overflow"); + } + return (long) x; + } + + @OpCodeIdentifier(OpCode.I64_TRUNC_F32_U) + public static long I64_TRUNC_F32_U(float x) { + if (Float.isNaN(x)) { + throw new WasmRuntimeException("invalid conversion to integer"); + } + if (x >= 2 * (float) Long.MAX_VALUE) { + throw new WasmRuntimeException("integer overflow"); + } + + if (x < Long.MAX_VALUE) { + long v = (long) x; + if (v < 0) { + throw new WasmRuntimeException("integer overflow"); + } + return v; + } + + // This works for getting the unsigned value because binary addition + // yields the correct interpretation in both unsigned and 2's-complement, + // no matter which the operands are considered to be. + long v = Long.MAX_VALUE + (long) (x - (float) Long.MAX_VALUE) + 1; + + // Java's comparison operators assume signed integers. In the case + // that we're in the range of unsigned values where the sign bit + // is set, Java considers these values to be negative, so we have + // to check for >= 0 to detect overflow. + if (v >= 0) { + throw new WasmRuntimeException("integer overflow"); + } + return v; + } + + @OpCodeIdentifier(OpCode.I64_TRUNC_F64_S) + public static long I64_TRUNC_F64_S(double x) { + if (Double.isNaN(x)) { + throw new WasmRuntimeException("invalid conversion to integer"); + } + if (x == (double) Long.MIN_VALUE) { + return Long.MIN_VALUE; + } + long v = (long) x; + if (v == Long.MIN_VALUE || v == Long.MAX_VALUE) { + throw new WasmRuntimeException("integer overflow"); + } + return v; + } + + @OpCodeIdentifier(OpCode.I64_TRUNC_F64_U) + public static long I64_TRUNC_F64_U(double x) { + if (Double.isNaN(x)) { + throw new WasmRuntimeException("invalid conversion to integer"); + } + if (x >= 2 * (double) Long.MAX_VALUE) { + throw new WasmRuntimeException("integer overflow"); + } + + if (x < Long.MAX_VALUE) { + long v = (long) x; + if (v < 0) { + throw new WasmRuntimeException("integer overflow"); + } + return v; + } + + // See I64_TRUNC_F32_U for notes on implementation. + // This is the double-based equivalent of that. + long v = Long.MAX_VALUE + (long) (x - (double) Long.MAX_VALUE) + 1; + if (v >= 0) { + throw new WasmRuntimeException("integer overflow"); + } + return v; + } + + @OpCodeIdentifier(OpCode.I64_TRUNC_SAT_F32_S) + public static long I64_TRUNC_SAT_F32_S(float x) { + if (Float.isNaN(x)) { + return 0; + } + if (x <= Long.MIN_VALUE) { + return Long.MIN_VALUE; + } + if (x >= Long.MAX_VALUE) { + return Long.MAX_VALUE; + } + return (long) x; + } + + @OpCodeIdentifier(OpCode.I64_TRUNC_SAT_F32_U) + public static long I64_TRUNC_SAT_F32_U(float x) { + if (Float.isNaN(x) || x < 0) { + return 0; + } + if (x > Math.pow(2, 64) - 1) { + return 0xFFFFFFFFFFFFFFFFL; + } + if (x < Long.MAX_VALUE) { + return (long) x; + } + + // See I64_TRUNC_F32_U for notes on implementation. + // This is the double-based equivalent of that. + long v = Long.MAX_VALUE + (long) (x - (double) Long.MAX_VALUE) + 1; + if (v >= 0) { + throw new WasmRuntimeException("integer overflow"); + } + return v; + } + + @OpCodeIdentifier(OpCode.I64_TRUNC_SAT_F64_S) + public static long I64_TRUNC_SAT_F64_S(double x) { + if (Double.isNaN(x)) { + return 0; + } + if (x <= Long.MIN_VALUE) { + return Long.MIN_VALUE; + } + if (x >= Long.MAX_VALUE) { + return Long.MAX_VALUE; + } + return (long) x; + } + + @OpCodeIdentifier(OpCode.I64_TRUNC_SAT_F64_U) + public static long I64_TRUNC_SAT_F64_U(double x) { + long v; + if (Double.isNaN(x) || x < 0) { + return 0L; + } + if (x > Math.pow(2, 64) - 1) { + return 0xFFFFFFFFFFFFFFFFL; + } + if (x < Long.MAX_VALUE) { + return (long) x; + } + + // See I64_TRUNC_F32_U for notes on implementation. + // This is the double-based equivalent of that. + v = Long.MAX_VALUE + (long) (x - (double) Long.MAX_VALUE) + 1; + if (v >= 0) { + throw new WasmRuntimeException("integer overflow"); + } + return v; + } + + // ========= F32 ========= + + @OpCodeIdentifier(OpCode.F32_ABS) + public static float F32_ABS(float x) { + return Math.abs(x); + } + + @OpCodeIdentifier(OpCode.F32_CEIL) + public static float F32_CEIL(float x) { + return (float) Math.ceil(x); + } + + @OpCodeIdentifier(OpCode.F32_CONVERT_I32_S) + public static float F32_CONVERT_I32_S(int x) { + return x; + } + + @OpCodeIdentifier(OpCode.F32_CONVERT_I32_U) + public static float F32_CONVERT_I32_U(int x) { + return Integer.toUnsignedLong(x); + } + + @OpCodeIdentifier(OpCode.F32_CONVERT_I64_S) + public static float F32_CONVERT_I64_S(long x) { + return x; + } + + @OpCodeIdentifier(OpCode.F32_CONVERT_I64_U) + public static float F32_CONVERT_I64_U(long x) { + if (x >= 0) { + return x; + } + // only preserve 24 bits of precision (plus one for rounding) to + // avoid rounding errors (64 - 24 == 40) + long sum = x + 0xff_ffff_ffffL; + // did the add overflow? add the MSB back on after the shift + long shiftIn = ((sum ^ x) & Long.MIN_VALUE) >>> 39; + return Math.scalb((float) ((sum >>> 40) | shiftIn), 40); + } + + @OpCodeIdentifier(OpCode.F32_COPYSIGN) + public static float F32_COPYSIGN(float a, float b) { + if (b == 0xFFC00000L) { // +NaN + return Math.copySign(a, -1); + } + if (b == 0x7FC00000L) { // -NaN + return Math.copySign(a, +1); + } + return Math.copySign(a, b); + } + + @OpCodeIdentifier(OpCode.F32_EQ) + public static int F32_EQ(float a, float b) { + return a == b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.F32_FLOOR) + public static float F32_FLOOR(float x) { + return (float) Math.floor(x); + } + + @OpCodeIdentifier(OpCode.F32_GE) + public static int F32_GE(float a, float b) { + return a >= b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.F32_GT) + public static int F32_GT(float a, float b) { + return a > b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.F32_LE) + public static int F32_LE(float a, float b) { + return a <= b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.F32_LT) + public static int F32_LT(float a, float b) { + return a < b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.F32_MAX) + public static float F32_MAX(float a, float b) { + return Math.max(a, b); + } + + @OpCodeIdentifier(OpCode.F32_MIN) + public static float F32_MIN(float a, float b) { + return Math.min(a, b); + } + + @OpCodeIdentifier(OpCode.F32_NE) + public static int F32_NE(float a, float b) { + return a == b ? FALSE : TRUE; + } + + @OpCodeIdentifier(OpCode.F32_NEAREST) + public static float F32_NEAREST(float x) { + return (float) Math.rint(x); + } + + @OpCodeIdentifier(OpCode.F32_REINTERPRET_I32) + public static float F32_REINTERPRET_I32(int x) { + return Float.intBitsToFloat(x); + } + + @OpCodeIdentifier(OpCode.F32_SQRT) + public static float F32_SQRT(float x) { + return (float) Math.sqrt(x); + } + + @OpCodeIdentifier(OpCode.F32_TRUNC) + public static float F32_TRUNC(float x) { + return (float) ((x < 0) ? Math.ceil(x) : Math.floor(x)); + } + + // ========= F64 ========= + + @OpCodeIdentifier(OpCode.F64_ABS) + public static double F64_ABS(double x) { + return Math.abs(x); + } + + @OpCodeIdentifier(OpCode.F64_CEIL) + public static double F64_CEIL(double x) { + return Math.ceil(x); + } + + @OpCodeIdentifier(OpCode.F64_CONVERT_I32_S) + public static double F64_CONVERT_I32_S(int x) { + return x; + } + + @OpCodeIdentifier(OpCode.F64_CONVERT_I32_U) + public static double F64_CONVERT_I32_U(int x) { + return Integer.toUnsignedLong(x); + } + + @OpCodeIdentifier(OpCode.F64_CONVERT_I64_S) + public static double F64_CONVERT_I64_S(long x) { + return x; + } + + @OpCodeIdentifier(OpCode.F64_CONVERT_I64_U) + public static double F64_CONVERT_I64_U(long tos) { + if (tos >= 0) { + return tos; + } + // only preserve 53 bits of precision (plus one for rounding) to + // avoid rounding errors (64 - 53 == 11) + long sum = tos + 0x3ff; + // did the add overflow? add the MSB back on after the shift + long shiftIn = ((sum ^ tos) & Long.MIN_VALUE) >>> 10; + return Math.scalb((double) ((sum >>> 11) | shiftIn), 11); + } + + @OpCodeIdentifier(OpCode.F64_COPYSIGN) + public static double F64_COPYSIGN(double a, double b) { + if (b == 0xFFC0000000000000L) { // +NaN + return Math.copySign(a, -1); + } + if (b == 0x7FC0000000000000L) { // -NaN + return Math.copySign(a, +1); + } + return Math.copySign(a, b); + } + + @OpCodeIdentifier(OpCode.F64_EQ) + public static int F64_EQ(double a, double b) { + return a == b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.F64_FLOOR) + public static double F64_FLOOR(double x) { + return Math.floor(x); + } + + @OpCodeIdentifier(OpCode.F64_GE) + public static int F64_GE(double a, double b) { + return a >= b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.F64_GT) + public static int F64_GT(double a, double b) { + return a > b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.F64_LE) + public static int F64_LE(double a, double b) { + return a <= b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.F64_LT) + public static int F64_LT(double a, double b) { + return a < b ? TRUE : FALSE; + } + + @OpCodeIdentifier(OpCode.F64_MAX) + public static double F64_MAX(double a, double b) { + return Math.max(a, b); + } + + @OpCodeIdentifier(OpCode.F64_MIN) + public static double F64_MIN(double a, double b) { + return Math.min(a, b); + } + + @OpCodeIdentifier(OpCode.F64_NE) + public static int F64_NE(double a, double b) { + return a == b ? FALSE : TRUE; + } + + @OpCodeIdentifier(OpCode.F64_NEAREST) + public static double F64_NEAREST(double x) { + return Math.rint(x); + } + + @OpCodeIdentifier(OpCode.F64_REINTERPRET_I64) + public static double F64_REINTERPRET_I64(long x) { + return Double.longBitsToDouble(x); + } + + @OpCodeIdentifier(OpCode.F64_SQRT) + public static double F64_SQRT(double x) { + return Math.sqrt(x); + } + + @OpCodeIdentifier(OpCode.F64_TRUNC) + public static double F64_TRUNC(double x) { + return (x < 0) ? Math.ceil(x) : Math.floor(x); + } + + // ========= Tables ========= + + public static int TABLE_GET(Instance instance, int tableIndex, int index) { + TableInstance table = instance.table(tableIndex); + if (index < 0 || index >= table.limits().max() || index >= table.size()) { + throw new WasmRuntimeException("out of bounds table access"); + } + return table.ref(index); + } + + public static void TABLE_FILL( + Instance instance, int tableIndex, int size, int value, int offset) { + int end = offset + size; + var table = instance.table(tableIndex); + + if (size < 0 || end > table.size()) { + throw new WasmRuntimeException("out of bounds table access"); + } + + for (int i = offset; i < end; i++) { + table.setRef(i, value, instance); + } + } + + public static void TABLE_COPY( + Instance instance, int srcTableIndex, int dstTableIndex, int size, int s, int d) { + var src = instance.table(srcTableIndex); + var dest = instance.table(dstTableIndex); + + if (size < 0 || (s < 0 || (size + s) > src.size()) || (d < 0 || (size + d) > dest.size())) { + throw new WasmRuntimeException("out of bounds table access"); + } + + for (int i = size - 1; i >= 0; i--) { + if (d <= s) { + var val = src.ref(s++); + var inst = src.instance(d); + dest.setRef(d++, (int) val, inst); + } else { + var val = src.ref(s + i); + var inst = src.instance(d + i); + dest.setRef(d + i, (int) val, inst); + } + } + } + + public static void TABLE_INIT( + Instance instance, int tableidx, int elementidx, int size, int elemidx, int offset) { + var end = offset + size; + var table = instance.table(tableidx); + + var elementCount = instance.elementCount(); + var currentElement = instance.element(elementidx); + var currentElementCount = + (currentElement instanceof PassiveElement) ? currentElement.elementCount() : 0; + boolean isOutOfBounds = + (size < 0 + || elementidx > elementCount + || (size > 0 && !(currentElement instanceof PassiveElement)) + || elemidx + size > currentElementCount + || end > table.size()); + + if (isOutOfBounds) { + throw new WasmRuntimeException("out of bounds table access"); + } + if (size == 0) { + return; + } + + for (int i = offset; i < end; i++) { + var elem = instance.element(elementidx); + var val = (int) computeConstantValue(instance, elem.initializers().get(elemidx++))[0]; + if (table.elementType().equals(ValType.FuncRef)) { + if (val > instance.functionCount()) { + throw new WasmRuntimeException("out of bounds table access"); + } + table.setRef(i, val, instance); + } else { + assert table.elementType().equals(ValType.ExternRef); + table.setRef(i, val, instance); + } + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/StackFrame.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/StackFrame.java new file mode 100644 index 000000000..4287fb584 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/StackFrame.java @@ -0,0 +1,218 @@ +package com.dylibso.chicory.runtime; + +import static com.dylibso.chicory.wasm.types.ValType.sizeOf; + +import com.dylibso.chicory.wasm.types.AnnotatedInstruction; +import com.dylibso.chicory.wasm.types.OpCode; +import com.dylibso.chicory.wasm.types.ValType; +import com.dylibso.chicory.wasm.types.Value; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +/** + * Represents a frame, doesn't hold the stack, just local variables and the `pc` which + * is the program counter in this function. Instead of keeping an absolute pointer + * to positions in code the program counter is relative to the function and we store it + * here so we know where to resume when we return from an inner function call. + * This also means it's not possible to set the program counter to an instruction in another function + * on accident, as this is not allowed in the spec. You can only jump to instructions + * within the function you are in and only specific places. + */ +public class StackFrame { + private final List code; + private AnnotatedInstruction currentInstruction; + + private final int funcId; + private int pc; + private final long[] locals; + private final ValType[] localTypes; + private final int[] localIdx; + private final Instance instance; + + private final List ctrlStack = new ArrayList<>(); + + public StackFrame(Instance instance, int funcId, long[] args) { + this( + instance, + funcId, + args, + Collections.emptyList(), + Collections.emptyList(), + Collections.emptyList()); + } + + StackFrame( + Instance instance, + int funcId, + long[] args, + List argsTypes, + List localTypes, + List code) { + this.code = code; + this.instance = instance; + this.funcId = funcId; + this.locals = Arrays.copyOf(args, sizeOf(argsTypes) + sizeOf(localTypes)); + int localsSize = argsTypes.size() + localTypes.size(); + this.localTypes = new ValType[localsSize]; + for (int i = 0; i < argsTypes.size(); i++) { + this.localTypes[i] = argsTypes.get(i); + } + for (int i = 0; i < localTypes.size(); i++) { + this.localTypes[argsTypes.size() + i] = localTypes.get(i); + } + this.localIdx = new int[localsSize]; + + // initialize codesegment locals. + int j = 0; + for (var i = 0; i < localTypes.size(); i++) { + ValType type = localTypes.get(i); + var idx = j + sizeOf(argsTypes); + if (!type.equals(ValType.V128)) { + locals[idx] = Value.zero(type); + j += 1; + } else { + locals[idx] = Value.zero(ValType.I64); + locals[idx + 1] = Value.zero(ValType.I64); + j += 2; + } + } + + // initialize local indexes + j = 0; + for (int i = 0; i < this.localTypes.length; i++) { + this.localIdx[i] = j; + if (!localType(i).equals(ValType.V128)) { + j += 1; + } else { + j += 2; + } + } + } + + void reset(long[] args) { + for (int i = 0; i < locals.length; i++) { + setLocal(i, args[i]); + } + pc = 0; + } + + int funcId() { + return funcId; + } + + ValType localType(int i) { + return this.localTypes[i]; + } + + public int localIndexOf(int idx) { + return this.localIdx[idx]; + } + + void setLocal(int i, long v) { + this.locals[i] = v; + } + + long local(int i) { + return locals[i]; + } + + @Override + public String toString() { + var nameSec = instance.module().nameSection(); + var id = "[" + funcId + "]"; + if (nameSec != null) { + var funcName = nameSec.nameOfFunction(funcId); + if (funcName != null) { + id = funcName + id; + } + } + return id + "\n\tpc=" + pc + " locals=" + Arrays.toString(locals); + } + + AnnotatedInstruction loadCurrentInstruction() { + currentInstruction = code.get(pc++); + return currentInstruction; + } + + int currentPc() { + return pc - 1; + } + + boolean isLastBlock() { + return currentInstruction.depth() == 0; + } + + boolean terminated() { + return pc >= code.size(); + } + + void pushCtrl(CtrlFrame ctrlFrame) { + ctrlStack.add(ctrlFrame); + } + + void pushCtrl(OpCode opcode, int startValues, int returnValues, int height) { + ctrlStack.add(new CtrlFrame(opcode, startValues, returnValues, height)); + } + + void pushCtrl(OpCode opcode, int startValues, int returnValues, int height, int pc) { + ctrlStack.add(new CtrlFrame(opcode, startValues, returnValues, height, pc)); + } + + int ctrlStackSize() { + return ctrlStack.size(); + } + + CtrlFrame popCtrl() { + var ctrlFrame = ctrlStack.remove(ctrlStack.size() - 1); + return ctrlFrame; + } + + CtrlFrame popCtrl(int n) { + int mostRecentCallHeight = ctrlStack.size(); + while (true) { + if (ctrlStack.get(--mostRecentCallHeight).opCode == OpCode.CALL) { + break; + } + } + var finalHeight = ctrlStack.size() - (mostRecentCallHeight + n + 1); + CtrlFrame ctrlFrame = null; + while (ctrlStack.size() > finalHeight) { + ctrlFrame = popCtrl(); + } + return ctrlFrame; + } + + CtrlFrame popCtrlTillCall() { + while (true) { + var ctrlFrame = popCtrl(); + if (ctrlFrame.opCode == OpCode.CALL) { + return ctrlFrame; + } + } + } + + void jumpTo(int newPc) { + pc = newPc; + } + + static void doControlTransfer(CtrlFrame ctrlFrame, MStack stack) { + var endResults = ctrlFrame.startValues + ctrlFrame.endValues; // unwind stack + long[] returns = new long[endResults]; + for (int i = 0; i < returns.length; i++) { + if (stack.size() > 0) { + returns[i] = stack.pop(); + } + } + + while (stack.size() > ctrlFrame.height) { + stack.pop(); + } + + for (int i = 0; i < returns.length; i++) { + long value = returns[returns.length - 1 - i]; + stack.push(value); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Store.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Store.java new file mode 100644 index 000000000..418896d03 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/Store.java @@ -0,0 +1,190 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.WasmModule; +import com.dylibso.chicory.wasm.types.Export; +import com.dylibso.chicory.wasm.types.ExportSection; +import com.dylibso.chicory.wasm.types.FunctionType; +import java.util.LinkedHashMap; +import java.util.Objects; +import java.util.function.Function; + +/** + * The runtime storage for all function, global, memory, table instances. + */ +public class Store { + final LinkedHashMap functions = new LinkedHashMap<>(); + final LinkedHashMap globals = new LinkedHashMap<>(); + final LinkedHashMap memories = new LinkedHashMap<>(); + final LinkedHashMap tables = new LinkedHashMap<>(); + final LinkedHashMap tags = new LinkedHashMap<>(); + + public Store() {} + + /** + * Add a function to the store. + */ + public Store addFunction(ImportFunction... function) { + for (var f : function) { + functions.put(new QualifiedName(f.module(), f.name()), f); + } + return this; + } + + /** + * Add a global to the store. + */ + public Store addGlobal(ImportGlobal... global) { + for (var g : global) { + globals.put(new QualifiedName(g.module(), g.name()), g); + } + return this; + } + + /** + * Add a memory to the store. + */ + public Store addMemory(ImportMemory... memory) { + for (var m : memory) { + memories.put(new QualifiedName(m.module(), m.name()), m); + } + return this; + } + + /** + * Add a table to the store. + */ + public Store addTable(ImportTable... table) { + for (var t : table) { + tables.put(new QualifiedName(t.module(), t.name()), t); + } + return this; + } + + /** + * Add a tag to the store. + */ + public Store addTag(ImportTag... tag) { + for (var t : tag) { + tags.put(new QualifiedName(t.module(), t.name()), t); + } + return this; + } + + /** + * Add the contents of a {@link ImportValues} instance to the store. + */ + public Store addImportValues(ImportValues importValues) { + return this.addGlobal(importValues.globals()) + .addFunction(importValues.functions()) + .addMemory(importValues.memories()) + .addTable(importValues.tables()) + .addTag(importValues.tags()); + } + + /** + * Convert the contents of a store to a {@link ImportValues} instance. + */ + public ImportValues toImportValues() { + return ImportValues.builder() + .withFunctions(functions.values()) + .withGlobals(globals.values()) + .withMemories(memories.values()) + .withTables(tables.values()) + .withTags(tags.values()) + .build(); + } + + /** + * Register an instance in the store with the given name. + * All the exported functions, globals, memories, and tables are added to the store + * with the given name. + * + * For instance, if a module named "myModule" exports a function + * named "myFunction", the function will be added to the store with the name "myFunction.myModule". + * + */ + public Store register(String name, Instance instance) { + ExportSection exportSection = instance.module().exportSection(); + for (int i = 0; i < exportSection.exportCount(); i++) { + Export export = exportSection.getExport(i); + String exportName = export.name(); + switch (export.exportType()) { + case FUNCTION: + ExportFunction f = instance.export(exportName); + FunctionType ftype = instance.exportType(exportName); + this.addFunction( + new ImportFunction( + name, exportName, ftype, (inst, args) -> f.apply(args))); + break; + + case TABLE: + this.addTable( + new ImportTable(name, exportName, instance.table(export.index()))); + break; + + case MEMORY: + this.addMemory(new ImportMemory(name, exportName, instance.memory())); + break; + + case GLOBAL: + GlobalInstance g = instance.global(export.index()); + this.addGlobal(new ImportGlobal(name, exportName, g)); + break; + + case TAG: + this.addTag(new ImportTag(name, exportName, instance.tag(export.index()))); + break; + } + } + return this; + } + + /** + * A shorthand for instantiating a module and registering it in the store. + */ + public Instance instantiate(String name, WasmModule m) { + return this.instantiate( + name, imports -> Instance.builder(m).withImportValues(imports).build()); + } + + /** + * Creates an instance with the given factory and registers the result in the store. + */ + public Instance instantiate(String name, Function instanceFactory) { + ImportValues importValues = this.toImportValues(); + Instance instance = instanceFactory.apply(importValues); + register(name, instance); + return instance; + } + + /** + * QualifiedName is internally used to use pairs (moduleName, name) as keys in the store. + */ + static class QualifiedName { + private final String module; + private final String name; + + public QualifiedName(String module, String name) { + this.module = module; + this.name = name; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof QualifiedName)) { + return false; + } + QualifiedName qualifiedName = (QualifiedName) o; + return Objects.equals(module, qualifiedName.module) + && Objects.equals(name, qualifiedName.name); + } + + @Override + public int hashCode() { + return Objects.hash(module, name); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/TableInstance.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/TableInstance.java new file mode 100644 index 000000000..ca54b252b --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/TableInstance.java @@ -0,0 +1,85 @@ +package com.dylibso.chicory.runtime; + +import static com.dylibso.chicory.wasm.types.Value.REF_NULL_VALUE; + +import com.dylibso.chicory.wasm.ChicoryException; +import com.dylibso.chicory.wasm.UninstantiableException; +import com.dylibso.chicory.wasm.types.Table; +import com.dylibso.chicory.wasm.types.TableLimits; +import com.dylibso.chicory.wasm.types.ValType; +import java.util.Arrays; + +public class TableInstance { + + private final Table table; + private Instance[] instances; + private int[] refs; + + public TableInstance(Table table, int initialValue) { + this.table = table; + this.instances = new Instance[(int) table.limits().min()]; + refs = new int[(int) table.limits().min()]; + Arrays.fill(refs, initialValue); + } + + public int size() { + return refs.length; + } + + public ValType elementType() { + return table.elementType(); + } + + public TableLimits limits() { + return table.limits(); + } + + public int grow(int size, int value, Instance instance) { + var oldSize = refs.length; + var targetSize = oldSize + size; + if (size < 0 || targetSize > limits().max()) { + return -1; + } + var newRefs = Arrays.copyOf(refs, targetSize); + Arrays.fill(newRefs, oldSize, targetSize, value); + var newInstances = Arrays.copyOf(instances, targetSize); + Arrays.fill(newInstances, oldSize, targetSize, instance); + refs = newRefs; + instances = newInstances; + table.limits().grow(size); + return oldSize; + } + + public int ref(int index) { + if (index < 0 || index >= this.refs.length) { + throw new ChicoryException("undefined element"); + } + return this.refs[index]; + } + + public int requiredRef(int index) { + int ref = ref(index); + if (ref == REF_NULL_VALUE) { + throw new ChicoryException("uninitialized element " + index); + } + return ref; + } + + public void setRef(int index, int value, Instance instance) { + if (index < 0 || index >= this.refs.length || index >= this.instances.length) { + throw new UninstantiableException("out of bounds table access"); + } + this.refs[index] = value; + this.instances[index] = instance; + } + + public Instance instance(int index) { + return instances[index]; + } + + public void reset() { + for (int i = 0; i < refs.length; i++) { + this.refs[i] = REF_NULL_VALUE; + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/TagInstance.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/TagInstance.java new file mode 100644 index 000000000..bd7188e1b --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/TagInstance.java @@ -0,0 +1,31 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.TagType; + +public class TagInstance { + + private final TagType tag; + private FunctionType type; + + public TagInstance(TagType tag) { + this.tag = tag; + } + + public TagInstance(TagType tag, FunctionType type) { + this.tag = tag; + this.type = type; + } + + public TagType tagType() { + return tag; + } + + public void setType(FunctionType type) { + this.type = type; + } + + public FunctionType type() { + return type; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/TrapException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/TrapException.java new file mode 100644 index 000000000..a7155687b --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/TrapException.java @@ -0,0 +1,9 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.ChicoryException; + +public class TrapException extends ChicoryException { + public TrapException(String msg) { + super(msg); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/WasmException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/WasmException.java new file mode 100644 index 000000000..c49479780 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/WasmException.java @@ -0,0 +1,26 @@ +package com.dylibso.chicory.runtime; + +public class WasmException extends RuntimeException { + private final int tagIdx; + private final long[] args; + private final Instance instance; + + public WasmException(Instance instance, int tagIdx, long[] args) { + this.instance = instance; + this.tagIdx = tagIdx; + this.args = args.clone(); + this.setStackTrace(new StackTraceElement[0]); + } + + public Instance instance() { + return instance; + } + + public int tagIdx() { + return tagIdx; + } + + public long[] args() { + return args; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/WasmFunctionHandle.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/WasmFunctionHandle.java new file mode 100644 index 000000000..2b70815b8 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/WasmFunctionHandle.java @@ -0,0 +1,9 @@ +package com.dylibso.chicory.runtime; + +/** + * Represents a Java function that can be called from Wasm. + */ +@FunctionalInterface +public interface WasmFunctionHandle { + long[] apply(Instance instance, long... args); +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/WasmRuntimeException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/WasmRuntimeException.java new file mode 100644 index 000000000..dcd6b0322 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/WasmRuntimeException.java @@ -0,0 +1,17 @@ +package com.dylibso.chicory.runtime; + +import com.dylibso.chicory.wasm.ChicoryException; + +public class WasmRuntimeException extends ChicoryException { + public WasmRuntimeException(String msg) { + super(msg); + } + + public WasmRuntimeException(Throwable cause) { + super(cause); + } + + public WasmRuntimeException(String msg, Throwable cause) { + super(msg, cause); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/alloc/DefaultMemAllocStrategy.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/alloc/DefaultMemAllocStrategy.java new file mode 100644 index 000000000..80fea4dd7 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/alloc/DefaultMemAllocStrategy.java @@ -0,0 +1,33 @@ +package com.dylibso.chicory.runtime.alloc; + +/** + * Default memory allocation strategy that doubles the buffer size on growth. + * + * @deprecated Memory is now allocated by page (64KB each), so custom allocation + * strategies are no longer used. + */ +@Deprecated +public final class DefaultMemAllocStrategy implements MemAllocStrategy { + private final int max; + + public DefaultMemAllocStrategy(int max) { + this.max = max; + } + + @Override + public int initial(int min) { + return min; + } + + @Override + public int next(int current, int target) { + int next = (current <= 0) ? target : current; + while (next < target && next < max) { + next = next << 1; + if (next < 0) { + return max; + } + } + return Math.min(max, next); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/alloc/ExactMemAllocStrategy.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/alloc/ExactMemAllocStrategy.java new file mode 100644 index 000000000..9ca4e9d67 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/alloc/ExactMemAllocStrategy.java @@ -0,0 +1,23 @@ +package com.dylibso.chicory.runtime.alloc; + +/** + * Memory allocation strategy that allocates exactly the requested size. + * + * @deprecated Memory is now allocated by page (64KB each), so custom allocation + * strategies are no longer used. + */ +@Deprecated +public final class ExactMemAllocStrategy implements MemAllocStrategy { + + public ExactMemAllocStrategy() {} + + @Override + public int initial(int min) { + return min; + } + + @Override + public int next(int current, int target) { + return target; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/alloc/MemAllocStrategy.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/alloc/MemAllocStrategy.java new file mode 100644 index 000000000..62233cd0d --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/alloc/MemAllocStrategy.java @@ -0,0 +1,15 @@ +package com.dylibso.chicory.runtime.alloc; + +/** + * Strategy for allocating memory buffers. + * + * @deprecated Memory is now allocated by page (64KB each), so custom allocation + * strategies are no longer used. This interface will be removed in + * a future release. + */ +@Deprecated +public interface MemAllocStrategy { + int initial(int min); + + int next(int current, int target); +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/internal/CompilerInterpreterMachine.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/internal/CompilerInterpreterMachine.java new file mode 100644 index 000000000..0af6bfe96 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/runtime/internal/CompilerInterpreterMachine.java @@ -0,0 +1,101 @@ +package com.dylibso.chicory.runtime.internal; + +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.runtime.InterpreterMachine; +import com.dylibso.chicory.runtime.MStack; +import com.dylibso.chicory.runtime.StackFrame; +import com.dylibso.chicory.runtime.WasmException; +import com.dylibso.chicory.wasm.ChicoryException; +import com.dylibso.chicory.wasm.types.FunctionType; +import java.util.Deque; +import java.util.HashSet; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * This class is used by compiler generated classes. It MUST remain backwards compatible + * so that older generated code can run on newer versions of the library. + */ +public class CompilerInterpreterMachine extends InterpreterMachine { + + private static final HashSet usedInterpretedFunctions; + + static { + if (Boolean.parseBoolean( + System.getProperty("chicory.compiler.printUseOfInterpretedFunctions"))) { + usedInterpretedFunctions = new HashSet<>(); + } else { + usedInterpretedFunctions = null; + } + } + + Set interpretedFuncIds; + + public CompilerInterpreterMachine(Instance instance, int[] interpretedFuncIds) { + super(instance); + this.interpretedFuncIds = + java.util.Arrays.stream(interpretedFuncIds).boxed().collect(Collectors.toSet()); + } + + @Override + protected long[] call( + MStack stack, + Instance instance, + Deque callStack, + int funcId, + long[] args, + FunctionType callType, + boolean popResults) + throws ChicoryException { + if (usedInterpretedFunctions != null && !usedInterpretedFunctions.contains(funcId)) { + usedInterpretedFunctions.add(funcId); + System.err.println("Chicory: calling interpreted function " + funcId); + } + return super.call(stack, instance, callStack, funcId, args, callType, popResults); + } + + @Override + protected void CALL(Operands operands) { + var instance = instance(); + var funcId = (int) operands.get(0); + if (interpretedFuncIds.contains(funcId) || instance.function(funcId) == null) { + // continue interpreting for interpreted functions or imported functions + super.CALL(operands); + } else { + // We end up here after a function switched to interpreted mode, + // going back to Java bytecode. + // + // Must be an AOT function: switch back the to the AOT machine that's assigned to the + // instance. + + var stack = stack(); + var typeId = instance.functionType(funcId); + var type = instance.type(typeId); + var args = extractArgsForParams(stack, type.params()); + + try { + var results = instance.getMachine().call(funcId, args); + // a host function can return null or an array of ints + // which we will push onto the stack + if (results != null) { + for (var result : results) { + stack.push(result); + } + } + } catch (WasmException e) { + // we need at least an empty frame + var stackFrame = new StackFrame(instance, funcId, args); + THROW_REF(instance, instance.registerException(e), stack, stackFrame, callStack); + } + } + } + + @Override + protected boolean useCurrentInstanceInterpreter( + Instance instance, Instance refInstance, int funcId) { + // this function influence the behavior of CALL_INDIRECT without rewriting it + // if we are on the same instance and the next invoked function needs to stay + // in interpreted mode, alternatively go through `Machine::call` + return refInstance.equals(instance) && interpretedFuncIds.contains(funcId); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Main.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Main.java new file mode 100644 index 000000000..e35eb8c8d --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Main.java @@ -0,0 +1,35 @@ +package com.dylibso.chicory.wabt; + +public final class Main { + + public static void main(String[] args) { + String wat = generateBigWat(500000); + + Wat2Wasm.parse(wat); + } + + private static String generateBigWat(int funcCount) { + StringBuilder wat = new StringBuilder(); + + wat.append("(module\n"); + for (int func = 1; func <= funcCount; func++) { + wat.append(" (func $func_") + .append(func) + .append(" (export \"func_") + .append(func) + .append("\") (param i32) (result i32)\n"); + wat.append(" local.get 0\n"); + wat.append(" i32.const ").append(func).append('\n'); + wat.append(" i32.add\n"); + + if (func != 1) { + wat.append(" call $func_").append(func - 1).append('\n'); + } + + wat.append(" )\n"); + } + wat.append(")\n"); + + return wat.toString(); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Wat2Wasm.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Wat2Wasm.java new file mode 100644 index 000000000..f3be224ac --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Wat2Wasm.java @@ -0,0 +1,80 @@ +package com.dylibso.chicory.wabt; + +import com.dylibso.chicory.log.Logger; +import com.dylibso.chicory.log.SystemLogger; +import com.dylibso.chicory.runtime.ImportValues; +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.wasi.WasiExitException; +import com.dylibso.chicory.wasi.WasiOptions; +import com.dylibso.chicory.wasi.WasiPreview1; +import com.dylibso.chicory.wasm.WasmModule; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.UncheckedIOException; +import java.nio.charset.StandardCharsets; +import java.util.List; + +public final class Wat2Wasm { + private static final Logger logger = new SystemLogger(); + private static final WasmModule MODULE = Wat2WasmModule.load(); + + private Wat2Wasm() {} + + public static byte[] parse(InputStream is) { + return parse(is, "temp.wast"); + } + + public static byte[] parse(File file) { + try (InputStream is = new FileInputStream(file)) { + return parse(is, file.getName()); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + } + + public static byte[] parse(String wat) { + try (InputStream is = new ByteArrayInputStream(wat.getBytes(StandardCharsets.UTF_8))) { + return parse(is, "temp.wast"); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + } + + private static byte[] parse(InputStream is, String fileName) { + try (ByteArrayOutputStream stdoutStream = new ByteArrayOutputStream(); + ByteArrayOutputStream stderrStream = new ByteArrayOutputStream()) { + WasiOptions wasiOpts = + WasiOptions.builder() + .withStdin(is) + .withStdout(stdoutStream) + .withStderr(stderrStream) + .withArguments(List.of("wat2wasm", "-", "--output=-")) + .build(); + + try (var wasi = + WasiPreview1.builder().withLogger(logger).withOptions(wasiOpts).build()) { + ImportValues imports = + ImportValues.builder().addFunction(wasi.toHostFunctions()).build(); + Instance.builder(MODULE) + .withMachineFactory(Wat2WasmModule::create) + .withImportValues(imports) + .build(); + } catch (WasiExitException e) { + if (e.exitCode() != 0) { + throw new WatParseException( + stdoutStream.toString(StandardCharsets.UTF_8) + + stderrStream.toString(StandardCharsets.UTF_8), + e); + } + } + + return stdoutStream.toByteArray(); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Wat2WasmMachine.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Wat2WasmMachine.java new file mode 100644 index 000000000..48ed8970b --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Wat2WasmMachine.java @@ -0,0 +1,213594 @@ +package com.dylibso.chicory.wabt; + +public final class Wat2WasmMachine implements com.dylibso.chicory.runtime.Machine { + + private final com.dylibso.chicory.runtime.Instance instance; + + public Wat2WasmMachine(com.dylibso.chicory.runtime.Instance instance) { + this.instance = instance; + } + + public static long[] func_0(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[2]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + var imprt = instance.imports().function(0); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_1(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[2]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + var imprt = instance.imports().function(1); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_2(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[2]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + var imprt = instance.imports().function(2); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_3(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[2]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + var imprt = instance.imports().function(3); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_4(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[1]; + boxedArgs[0] = ((long) arg0); + var imprt = instance.imports().function(4); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_5(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[2]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + var imprt = instance.imports().function(5); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_6(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[2]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + var imprt = instance.imports().function(6); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_7(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[2]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + var imprt = instance.imports().function(7); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_8(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[3]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + boxedArgs[2] = ((long) arg2); + var imprt = instance.imports().function(8); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_9(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[4]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + boxedArgs[2] = ((long) arg2); + boxedArgs[3] = ((long) arg3); + var imprt = instance.imports().function(9); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_10(int arg0, long arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[4]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = arg1; + boxedArgs[2] = ((long) arg2); + boxedArgs[3] = ((long) arg3); + var imprt = instance.imports().function(10); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_11(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[4]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + boxedArgs[2] = ((long) arg2); + boxedArgs[3] = ((long) arg3); + var imprt = instance.imports().function(11); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_12(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[5]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + boxedArgs[2] = ((long) arg2); + boxedArgs[3] = ((long) arg3); + boxedArgs[4] = ((long) arg4); + var imprt = instance.imports().function(12); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_13(int arg0, int arg1, int arg2, int arg3, int arg4, long arg5, long arg6, int arg7, int arg8, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[9]; + boxedArgs[0] = ((long) arg0); + boxedArgs[1] = ((long) arg1); + boxedArgs[2] = ((long) arg2); + boxedArgs[3] = ((long) arg3); + boxedArgs[4] = ((long) arg4); + boxedArgs[5] = arg5; + boxedArgs[6] = arg6; + boxedArgs[7] = ((long) arg7); + boxedArgs[8] = ((long) arg8); + var imprt = instance.imports().function(13); + return imprt.handle().apply(instance, boxedArgs); + } + + public static long[] func_14(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] boxedArgs = new long[1]; + boxedArgs[0] = ((long) arg0); + var imprt = instance.imports().function(14); + return imprt.handle().apply(instance, boxedArgs); + } + + public static void func_15(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(1817, new long[0]); + instance.getMachine().call(35, new long[0]); + return; + } + + public static long[] call_15(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_15(memory, instance); + return null; + } + + public static void func_16(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_16(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_16(memory, instance); + return null; + } + + public static int func_17(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_17(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_17(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_18(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + label_1: { + label_2: { + if (memory.readInt((int) 0 < 0 ? 0 : 0 + 621952) != 0) { + break label_2; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621952, (int) 1); + instance.getMachine().call(15, new long[0]); + long[] callResult_1 = instance.getMachine().call(1791, new long[0]); + local0 = ((int) callResult_1[0]); + instance.getMachine().call(1826, new long[0]); + if (local0 != 0) { + break label_1; + } + return; + } + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local0); + instance.getMachine().call(1806, callArgs_3); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_18(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_18(memory, instance); + return null; + } + + public static void func_19(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) 0 < 0 ? 0 : 0 + 621967), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 621956)); + instance.getMachine().call(1777, callArgs_0); + } + return; + } + + public static long[] call_19(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_19(arg0, memory, instance); + return null; + } + + public static void func_20(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621968); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621968, (int) 0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + return; + } + + public static long[] call_20(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_20(arg0, memory, instance); + return null; + } + + public static int func_21(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + local2 = (((int) instance.global(0).getValue()) - 240); + instance.global(0).setValue(((long) local2)); + instance.getMachine().call(85, new long[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 38864); + callArgs_1[1] = ((long) 12990); + callArgs_1[0] = ((long) (local2 + 152)); + long[] callResult_1 = instance.getMachine().call(198, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) 39296); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) 1); + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) (local2 + 72)); + callArgs_2[3] = ((long) 12215); + callArgs_2[2] = ((long) 15611); + callArgs_2[1] = ((long) 118); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(208, callArgs_2); + label_1: { + local4 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 84) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : memory.readInt((int) local2 < 0 ? local2 : local2 + 84) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + int ciTableIdx_3 = (int) (local4); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) 39348); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) 2); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) (local2 + 72)); + callArgs_4[2] = ((long) 8595); + callArgs_4[1] = ((long) 11563); + callArgs_4[0] = ((long) local3); + instance.getMachine().call(201, callArgs_4); + label_2: { + local4 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 84) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : memory.readInt((int) local2 < 0 ? local2 : local2 + 84) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + int ciTableIdx_5 = (int) (local4); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) 39400); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) 3); + long[] callArgs_6 = new long[5]; + callArgs_6[4] = ((long) (local2 + 72)); + callArgs_6[3] = ((long) 5746); + callArgs_6[2] = ((long) 17025); + callArgs_6[1] = ((long) 100); + callArgs_6[0] = ((long) local3); + instance.getMachine().call(208, callArgs_6); + label_3: { + local4 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 84) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : memory.readInt((int) local2 < 0 ? local2 : local2 + 84) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + int ciTableIdx_7 = (int) (local4); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local3); + callArgs_8[0] = ((long) 62160); + instance.getMachine().call(89, callArgs_8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) 39452); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) 4); + long[] callArgs_9 = new long[6]; + callArgs_9[5] = ((long) (local2 + 72)); + callArgs_9[4] = ((long) 28856); + callArgs_9[3] = ((long) 27123); + callArgs_9[2] = ((long) 5733); + callArgs_9[1] = ((long) 111); + callArgs_9[0] = ((long) local3); + instance.getMachine().call(210, callArgs_9); + label_4: { + local4 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 84) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : memory.readInt((int) local2 < 0 ? local2 : local2 + 84) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + int ciTableIdx_10 = (int) (local4); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) 39504); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) 5); + long[] callArgs_11 = new long[5]; + callArgs_11[4] = ((long) (local2 + 72)); + callArgs_11[3] = ((long) 30395); + callArgs_11[2] = ((long) 17219); + callArgs_11[1] = ((long) 114); + callArgs_11[0] = ((long) local3); + instance.getMachine().call(208, callArgs_11); + label_5: { + local4 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 84) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : memory.readInt((int) local2 < 0 ? local2 : local2 + 84) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_5; + } + int ciTableIdx_12 = (int) (local4); + int ciFuncId_12 = instance.table(0).requiredRef(ciTableIdx_12); + com.dylibso.chicory.runtime.Instance ciRefInstance_12 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_12), instance); + if (!ciRefInstance_12.type(ciRefInstance_12.functionType(ciFuncId_12)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + ciRefInstance_12.getMachine().call(ciFuncId_12, callArgs_12); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) 39556); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) 6); + long[] callArgs_13 = new long[4]; + callArgs_13[3] = ((long) (local2 + 72)); + callArgs_13[2] = ((long) 15069); + callArgs_13[1] = ((long) 10455); + callArgs_13[0] = ((long) local3); + instance.getMachine().call(201, callArgs_13); + label_6: { + local4 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 84) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : memory.readInt((int) local2 < 0 ? local2 : local2 + 84) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_6; + } + int ciTableIdx_14 = (int) (local4); + int ciFuncId_14 = instance.table(0).requiredRef(ciTableIdx_14); + com.dylibso.chicory.runtime.Instance ciRefInstance_14 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_14), instance); + if (!ciRefInstance_14.type(ciRefInstance_14.functionType(ciFuncId_14)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + ciRefInstance_14.getMachine().call(ciFuncId_14, callArgs_14); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) 39608); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) 7); + long[] callArgs_15 = new long[4]; + callArgs_15[3] = ((long) (local2 + 72)); + callArgs_15[2] = ((long) 17151); + callArgs_15[1] = ((long) 8541); + callArgs_15[0] = ((long) local3); + instance.getMachine().call(201, callArgs_15); + label_7: { + local4 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 84) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : memory.readInt((int) local2 < 0 ? local2 : local2 + 84) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_7; + } + int ciTableIdx_16 = (int) (local4); + int ciFuncId_16 = instance.table(0).requiredRef(ciTableIdx_16); + com.dylibso.chicory.runtime.Instance ciRefInstance_16 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_16), instance); + if (!ciRefInstance_16.type(ciRefInstance_16.functionType(ciFuncId_16)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + ciRefInstance_16.getMachine().call(ciFuncId_16, callArgs_16); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) 39660); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) 8); + long[] callArgs_17 = new long[4]; + callArgs_17[3] = ((long) (local2 + 72)); + callArgs_17[2] = ((long) 8563); + callArgs_17[1] = ((long) 14026); + callArgs_17[0] = ((long) local3); + instance.getMachine().call(201, callArgs_17); + label_8: { + local4 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 84) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : memory.readInt((int) local2 < 0 ? local2 : local2 + 84) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_8; + } + int ciTableIdx_18 = (int) (local4); + int ciFuncId_18 = instance.table(0).requiredRef(ciTableIdx_18); + com.dylibso.chicory.runtime.Instance ciRefInstance_18 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_18), instance); + if (!ciRefInstance_18.type(ciRefInstance_18.functionType(ciFuncId_18)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + ciRefInstance_18.getMachine().call(ciFuncId_18, callArgs_18); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 144, (byte) (0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 136, (long) 7308604897068083558L); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 147, (byte) (8)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) 39712); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) 9); + long[] callArgs_19 = new long[4]; + callArgs_19[3] = ((long) (local2 + 72)); + callArgs_19[2] = ((long) 0); + callArgs_19[1] = ((long) (local2 + 136)); + callArgs_19[0] = ((long) local3); + instance.getMachine().call(206, callArgs_19); + label_9: { + local4 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 84) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : memory.readInt((int) local2 < 0 ? local2 : local2 + 84) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_9; + } + int ciTableIdx_20 = (int) (local4); + int ciFuncId_20 = instance.table(0).requiredRef(ciTableIdx_20); + com.dylibso.chicory.runtime.Instance ciRefInstance_20 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_20), instance); + if (!ciRefInstance_20.type(ciRefInstance_20.functionType(ciFuncId_20)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + ciRefInstance_20.getMachine().call(ciFuncId_20, callArgs_20); + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 147), -1) != 0) { + break label_10; + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 136)); + instance.getMachine().call(1777, callArgs_21); + } + long[] callArgs_22 = new long[3]; + callArgs_22[2] = ((long) arg1); + callArgs_22[1] = ((long) arg0); + callArgs_22[0] = ((long) local3); + instance.getMachine().call(212, callArgs_22); + label_11: { + arg1 = memory.readInt((int) memory.readInt((int) (local3 + 60) < 0 ? (local3 + 60) : (local3 + 60) + 0) < 0 ? memory.readInt((int) (local3 + 60) < 0 ? (local3 + 60) : (local3 + 60) + 0) : memory.readInt((int) (local3 + 60) < 0 ? (local3 + 60) : (local3 + 60) + 0) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_11; + } + int ciTableIdx_23 = (int) (arg1); + int ciFuncId_23 = instance.table(0).requiredRef(ciTableIdx_23); + com.dylibso.chicory.runtime.Instance ciRefInstance_23 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_23), instance); + if (!ciRefInstance_23.type(ciRefInstance_23.functionType(ciFuncId_23)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + ciRefInstance_23.getMachine().call(ciFuncId_23, callArgs_23); + } + label_12: { + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_12; + } + arg1 = local4; + label_13: { + arg0 = memory.readInt((int) (local3 + 40) < 0 ? (local3 + 40) : (local3 + 40) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, arg0) != 0) { + break label_13; + } + arg1 = (arg0 + -36); + label_14: while (true) { + label_15: { + arg0 = memory.readInt((int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0) < 0 ? memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0) : memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_15; + } + int ciTableIdx_24 = (int) (arg0); + int ciFuncId_24 = instance.table(0).requiredRef(ciTableIdx_24); + com.dylibso.chicory.runtime.Instance ciRefInstance_24 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_24), instance); + if (!ciRefInstance_24.type(ciRefInstance_24.functionType(ciFuncId_24)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + ciRefInstance_24.getMachine().call(ciFuncId_24, callArgs_24); + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (arg1 + 11) < 0 ? (arg1 + 11) : (arg1 + 11) + 0), -1) != 0) { + break label_16; + } + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_25); + } + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, arg1); + arg1 = (arg1 + -36); + if (arg0 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 36); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) local4); + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_26); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 72, (int) (local3 + 24)); + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) (local2 + 72)); + instance.getMachine().call(31, callArgs_27); + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 23), -1) != 0) { + break label_17; + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 12)); + instance.getMachine().call(1777, callArgs_28); + } + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), -1) != 0) { + break label_18; + } + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_29); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 144, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 136, (long) 0L); + arg1 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621972); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 128, (int) arg1); + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) arg1); + long[] callResult_30 = instance.getMachine().call(1897, callArgs_30); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 132, (int) ((int) callResult_30[0])); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 128)); + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) (local2 + 136)); + callArgs_31[0] = ((long) (local2 + 48)); + long[] callResult_31 = instance.getMachine().call(82, callArgs_31); + arg0 = ((int) callResult_31[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 120, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 112, (long) 0L); + arg1 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621972); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 104, (int) arg1); + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) arg1); + long[] callResult_32 = instance.getMachine().call(1897, callArgs_32); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 108, (int) ((int) callResult_32[0])); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 136); + long[] callArgs_33 = new long[4]; + callArgs_33[3] = ((long) (local2 + 112)); + callArgs_33[2] = ((long) (memory.readInt((int) local2 < 0 ? local2 : local2 + 140) - arg1)); + callArgs_33[1] = ((long) arg1); + callArgs_33[0] = ((long) (local2 + 40)); + long[] callResult_33 = instance.getMachine().call(556, callArgs_33); + arg1 = ((int) callResult_33[0]); + label_19: { + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0) != 0) { + break label_20; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) 0); + memory.writeI32((int) (local2 + 167) < 0 ? (local2 + 167) : (local2 + 167) + 0, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 62175)); + memory.writeLong((int) ((local2 + 152) + 8) < 0 ? ((local2 + 152) + 8) : ((local2 + 152) + 8) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 62168)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 152, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 62160)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 171, (byte) (0)); + label_21: { + long[] callArgs_34 = new long[4]; + callArgs_34[3] = ((long) (local2 + 152)); + callArgs_34[2] = ((long) (local2 + 112)); + callArgs_34[1] = ((long) (local2 + 96)); + callArgs_34[0] = ((long) arg1); + long[] callResult_34 = instance.getMachine().call(1307, callArgs_34); + local4 = ((int) callResult_34[0]); + if (local4 != 0) { + break label_21; + } + label_22: { + if (((int) memory.read((int) 0 < 0 ? 0 : 0 + 621976) & 0xFF) != 0) { + break label_22; + } + memory.writeI32((int) (local2 + 87) < 0 ? (local2 + 87) : (local2 + 87) + 0, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 62175)); + memory.writeLong((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 62168)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 62160)); + long[] callArgs_35 = new long[3]; + callArgs_35[2] = ((long) (local2 + 72)); + callArgs_35[1] = ((long) (local2 + 112)); + callArgs_35[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 96)); + long[] callResult_35 = instance.getMachine().call(457, callArgs_35); + local4 = ((int) callResult_35[0]); + if (local4 != 0) { + break label_21; + } + } + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 621968)); + callArgs_36[0] = ((long) (local2 + 72)); + long[] callResult_36 = instance.getMachine().call(229, callArgs_36); + arg0 = ((int) callResult_36[0]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 62194, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 62175)); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 62187, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 62168)); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 62179, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 62160)); + label_23: { + long[] callArgs_37 = new long[3]; + callArgs_37[2] = ((long) 62179); + callArgs_37[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 96)); + callArgs_37[0] = ((long) arg0); + long[] callResult_37 = instance.getMachine().call(40, callArgs_37); + local4 = ((int) callResult_37[0]); + if (local4 != 0) { + break label_23; + } + label_24: { + local3 = ((int) memory.read((int) 0 < 0 ? 0 : 0 + 621967) & 0xFF); + _snap_0 = local3; + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3); + if ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0 ? memory.readInt((int) 0 < 0 ? 0 : 0 + 621960) : _snap_0) != 0) { + break label_24; + } + local3 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621972); + long[] callArgs_38 = new long[1]; + callArgs_38[0] = ((long) local3); + long[] callResult_38 = instance.getMachine().call(1897, callArgs_38); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 220, (int) ((int) callResult_38[0])); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 216, (int) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 216)); + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) (local2 + 32)); + callArgs_39[0] = ((long) (local2 + 224)); + instance.getMachine().call(111, callArgs_39); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 224)); + long[] callArgs_40 = new long[2]; + callArgs_40[1] = ((long) (local2 + 24)); + callArgs_40[0] = ((long) (local2 + 232)); + instance.getMachine().call(110, callArgs_40); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 236); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_19; + } + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 232); + label_25: { + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_26; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 67, (byte) (local3)); + local6 = (local2 + 56); + break label_25; + } + local7 = ((local3 | 15) + 1); + long[] callArgs_41 = new long[1]; + callArgs_41[0] = ((long) local7); + long[] callResult_41 = instance.getMachine().call(1776, callArgs_41); + local6 = ((int) callResult_41[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 64, (int) (local7 | -2147483648)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 60, (int) local3); + } + long[] callArgs_42 = new long[3]; + callArgs_42[2] = ((long) local3); + callArgs_42[1] = ((long) local5); + callArgs_42[0] = ((long) local6); + long[] callResult_42 = instance.getMachine().call(1891, callArgs_42); + memory.writeByte((int) (((int) callResult_42[0]) + local3) < 0 ? (((int) callResult_42[0]) + local3) : (((int) callResult_42[0]) + local3) + 0, (byte) (0)); + long[] callArgs_43 = new long[2]; + callArgs_43[1] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 62396)); + callArgs_43[0] = ((long) (local2 + 56)); + long[] callResult_43 = instance.getMachine().call(1662, callArgs_43); + label_27: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) 0 < 0 ? 0 : 0 + 621967), -1) != 0) { + break label_27; + } + long[] callArgs_44 = new long[1]; + callArgs_44[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 621956)); + instance.getMachine().call(1777, callArgs_44); + } + memory.writeLong((int) 0 < 0 ? 0 : 0 + 621956, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621964, (int) memory.readInt((int) (local2 + 64) < 0 ? (local2 + 64) : (local2 + 64) + 0)); + local3 = ((int) memory.read((int) 0 < 0 ? 0 : 0 + 621967) & 0xFF); + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0) != 0 ? memory.readInt((int) 0 < 0 ? 0 : 0 + 621956) : 621956); + long[] callArgs_45 = new long[1]; + callArgs_45[0] = ((long) local5); + long[] callResult_45 = instance.getMachine().call(1897, callArgs_45); + local6 = ((int) callResult_45[0]); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) 0 < 0 ? 0 : 0 + 621984) & 0xFF)) != 0) { + break label_28; + } + long[] callResult_46 = instance.getMachine().call(240, new long[0]); + local7 = ((int) callResult_46[0]); + label_29: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) 0 < 0 ? 0 : 0 + 621980)) != 0) { + break label_29; + } + long[] callArgs_47 = new long[3]; + callArgs_47[2] = ((long) 0); + callArgs_47[1] = ((long) 31840); + callArgs_47[0] = ((long) local7); + instance.getMachine().call(223, callArgs_47); + } + label_30: { + local8 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local9 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, local8) != 0) { + break label_30; + } + long[] callArgs_48 = new long[7]; + callArgs_48[6] = ((long) 0); + callArgs_48[5] = ((long) 0); + callArgs_48[4] = ((long) 0); + callArgs_48[3] = ((long) 0); + callArgs_48[2] = ((long) (local9 - local8)); + callArgs_48[1] = ((long) local8); + callArgs_48[0] = ((long) local7); + instance.getMachine().call(222, callArgs_48); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_28; + } + int ciTableIdx_49 = (int) (memory.readInt((int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0) < 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 0) : memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 4)); + int ciFuncId_49 = instance.table(0).requiredRef(ciTableIdx_49); + com.dylibso.chicory.runtime.Instance ciRefInstance_49 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_49), instance); + if (!ciRefInstance_49.type(ciRefInstance_49.functionType(ciFuncId_49)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_49 = new long[1]; + callArgs_49[0] = ((long) local7); + ciRefInstance_49.getMachine().call(ciFuncId_49, callArgs_49); + } + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local6) != 0) { + break label_31; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(45, ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) != 0) { + break label_31; + } + long[] callArgs_50 = new long[1]; + callArgs_50[0] = ((long) local3); + long[] callResult_50 = instance.getMachine().call(228, callArgs_50); + break label_23; + } + local10 = ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local6) << 32L) | com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local5)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) local10); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) local10); + long[] callArgs_51 = new long[2]; + callArgs_51[1] = ((long) (local2 + 16)); + callArgs_51[0] = ((long) local3); + long[] callResult_51 = instance.getMachine().call(227, callArgs_51); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (41876 + 8)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_21; + } + label_32: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_32; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg0); + long[] callArgs_52 = new long[1]; + callArgs_52[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_52); + } + long[] callArgs_53 = new long[1]; + callArgs_53[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_53); + } + long[] callArgs_54 = new long[1]; + callArgs_54[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callResult_54 = instance.getMachine().call(186, callArgs_54); + arg0 = ((int) callResult_54[0]); + long[] callArgs_55 = new long[1]; + callArgs_55[0] = ((long) 24); + long[] callResult_55 = instance.getMachine().call(1776, callArgs_55); + long[] callArgs_56 = new long[2]; + callArgs_56[1] = ((long) arg0); + callArgs_56[0] = ((long) ((int) callResult_55[0])); + long[] callResult_56 = instance.getMachine().call(181, callArgs_56); + arg0 = ((int) callResult_56[0]); + memory.writeI32((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) 0L); + long[] callArgs_57 = new long[7]; + callArgs_57[6] = ((long) 80); + callArgs_57[5] = ((long) 0); + callArgs_57[4] = ((long) (local2 + 72)); + callArgs_57[3] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + callArgs_57[2] = ((long) arg0); + callArgs_57[1] = ((long) 0); + callArgs_57[0] = ((long) (local2 + 112)); + instance.getMachine().call(88, callArgs_57); + label_33: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 83), -1) != 0) { + break label_33; + } + long[] callArgs_58 = new long[1]; + callArgs_58[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + instance.getMachine().call(1777, callArgs_58); + } + label_34: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_34; + } + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) local3); + long[] callArgs_59 = new long[1]; + callArgs_59[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_59); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 0); + label_35: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_35; + } + long[] callArgs_60 = new long[1]; + callArgs_60[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_60); + } + long[] callArgs_61 = new long[1]; + callArgs_61[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_61); + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 96); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) 0); + label_36: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_36; + } + long[] callArgs_62 = new long[1]; + callArgs_62[0] = ((long) arg0); + long[] callResult_62 = instance.getMachine().call(32, callArgs_62); + long[] callArgs_63 = new long[1]; + callArgs_63[0] = ((long) ((int) callResult_62[0])); + instance.getMachine().call(1777, callArgs_63); + } + label_37: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15), -1) != 0) { + break label_37; + } + long[] callArgs_64 = new long[1]; + callArgs_64[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + instance.getMachine().call(1777, callArgs_64); + } + arg0 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + label_38: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_38; + } + long[] callArgs_65 = new long[1]; + callArgs_65[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_65); + } + long[] callArgs_66 = new long[1]; + callArgs_66[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_66); + label_39: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 112); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_39; + } + arg1 = local3; + label_40: { + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 116); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg0) != 0) { + break label_40; + } + arg1 = (arg0 + -12); + label_41: while (true) { + label_42: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (arg1 + 11) < 0 ? (arg1 + 11) : (arg1 + 11) + 0), -1) != 0) { + break label_42; + } + long[] callArgs_67 = new long[1]; + callArgs_67[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_67); + } + arg0 = (arg1 + -24); + arg1 = (arg1 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_41; + } + break; + } + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 112); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 116, (int) local3); + long[] callArgs_68 = new long[1]; + callArgs_68[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_68); + } + label_43: { + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 136); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_43; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 140, (int) arg1); + long[] callArgs_69 = new long[1]; + callArgs_69[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_69); + } + instance.global(0).setValue(((long) (local2 + 240))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 621972)); + long[] callArgs_70 = new long[3]; + callArgs_70[2] = ((long) local2); + callArgs_70[1] = ((long) 31650); + callArgs_70[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + long[] callResult_70 = instance.getMachine().call(1847, callArgs_70); + long[] callArgs_71 = new long[1]; + callArgs_71[0] = ((long) 1); + instance.getMachine().call(1827, callArgs_71); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_21(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_21(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_22(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621980, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 621980) + 1)); + long[] callResult_0 = instance.getMachine().call(241, new long[0]); + local1 = ((int) callResult_0[0]); + local2 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621968); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621968, (int) local1); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + } + return; + } + + public static long[] call_22(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_22(arg0, memory, instance); + return null; + } + + public static void func_23(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return; + } + + public static long[] call_23(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_23(arg0, memory, instance); + return null; + } + + public static void func_24(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeByte((int) 0 < 0 ? 0 : 0 + 621984, (byte) (1)); + return; + } + + public static long[] call_24(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_24(arg0, memory, instance); + return null; + } + + public static void func_25(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) 621956); + long[] callResult_0 = instance.getMachine().call(1650, callArgs_0); + return; + } + + public static long[] call_25(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_25(arg0, arg1, memory, instance); + return null; + } + + public static void func_26(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeByte((int) 0 < 0 ? 0 : 0 + 62199, (byte) (1)); + return; + } + + public static long[] call_26(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_26(arg0, memory, instance); + return null; + } + + public static void func_27(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeByte((int) 0 < 0 ? 0 : 0 + 62198, (byte) (0)); + return; + } + + public static long[] call_27(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_27(arg0, memory, instance); + return null; + } + + public static void func_28(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeByte((int) 0 < 0 ? 0 : 0 + 62200, (byte) (1)); + return; + } + + public static long[] call_28(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_28(arg0, memory, instance); + return null; + } + + public static void func_29(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeByte((int) 0 < 0 ? 0 : 0 + 621976, (byte) (1)); + return; + } + + public static long[] call_29(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_29(arg0, memory, instance); + return null; + } + + public static void func_30(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621972, (int) arg1); + return; + } + + public static long[] call_30(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_30(arg0, arg1, memory, instance); + return null; + } + + public static void func_31(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + local3 = local2; + label_2: { + local4 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local4) != 0) { + break label_2; + } + local3 = (local4 + -56); + label_3: while (true) { + label_4: { + local4 = memory.readInt((int) memory.readInt((int) (local3 + 52) < 0 ? (local3 + 52) : (local3 + 52) + 0) < 0 ? memory.readInt((int) (local3 + 52) < 0 ? (local3 + 52) : (local3 + 52) + 0) : memory.readInt((int) (local3 + 52) < 0 ? (local3 + 52) : (local3 + 52) + 0) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + int ciTableIdx_0 = (int) (local4); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) (local3 + 40) < 0 ? (local3 + 40) : (local3 + 40) + 0)); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local3 + 39) < 0 ? (local3 + 39) : (local3 + 39) + 0), -1) != 0) { + break label_5; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0)); + instance.getMachine().call(1777, callArgs_1); + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local3 + 23) < 0 ? (local3 + 23) : (local3 + 23) + 0), -1) != 0) { + break label_6; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0)); + instance.getMachine().call(1777, callArgs_2); + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local3 + 11) < 0 ? (local3 + 11) : (local3 + 11) + 0), -1) != 0) { + break label_7; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_3); + } + local4 = (local3 + -4); + local3 = (local3 + -60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local3 = memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 0); + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local2); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_4); + } + return; + } + + public static long[] call_31(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_31(arg0, memory, instance); + return null; + } + + public static int func_32(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) (arg0 + 396) < 0 ? (arg0 + 396) : (arg0 + 396) + 0)); + callArgs_0[0] = ((long) (arg0 + 392)); + instance.getMachine().call(34, callArgs_0); + label_1: { + local1 = memory.readInt((int) (arg0 + 376) < 0 ? (arg0 + 376) : (arg0 + 376) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_2); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 368); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 368, (int) 0); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_3); + } + label_5: { + local1 = memory.readInt((int) (arg0 + 356) < 0 ? (arg0 + 356) : (arg0 + 356) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_5; + } + label_6: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_7; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_5); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 348); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 348, (int) 0); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_8; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_6); + } + label_9: { + local1 = memory.readInt((int) (arg0 + 336) < 0 ? (arg0 + 336) : (arg0 + 336) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_9; + } + label_10: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_11; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_7); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_8); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 328); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 328, (int) 0); + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_12; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_9); + } + label_13: { + local1 = memory.readInt((int) (arg0 + 316) < 0 ? (arg0 + 316) : (arg0 + 316) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_13; + } + label_14: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_15; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_10); + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_11); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 308); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 308, (int) 0); + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_16; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_12); + } + label_17: { + local1 = memory.readInt((int) (arg0 + 296) < 0 ? (arg0 + 296) : (arg0 + 296) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_17; + } + label_18: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_19; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_13); + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_14); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 288); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 288, (int) 0); + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_20; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_15); + } + label_21: { + local1 = memory.readInt((int) (arg0 + 276) < 0 ? (arg0 + 276) : (arg0 + 276) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_21; + } + label_22: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_23; + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_16); + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_17); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_22; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 268); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 268, (int) 0); + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_24; + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_18); + } + label_25: { + local1 = memory.readInt((int) (arg0 + 256) < 0 ? (arg0 + 256) : (arg0 + 256) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_25; + } + label_26: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_27: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_27; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_19); + } + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_20); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_26; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 248); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 248, (int) 0); + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_28; + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_21); + } + label_29: { + local1 = memory.readInt((int) (arg0 + 236) < 0 ? (arg0 + 236) : (arg0 + 236) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_29; + } + label_30: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_31; + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_22); + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_23); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_30; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 228); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 228, (int) 0); + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_32; + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_24); + } + label_33: { + local1 = memory.readInt((int) (arg0 + 216) < 0 ? (arg0 + 216) : (arg0 + 216) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_33; + } + label_34: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_35: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_35; + } + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_25); + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_26); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_34; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 208); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 208, (int) 0); + label_36: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_36; + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_27); + } + label_37: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 196); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_37; + } + local1 = local3; + label_38: { + local2 = memory.readInt((int) (arg0 + 200) < 0 ? (arg0 + 200) : (arg0 + 200) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_38; + } + local1 = (local2 + -44); + label_39: while (true) { + label_40: { + local2 = memory.readInt((int) (local1 + 12) < 0 ? (local1 + 12) : (local1 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_40; + } + memory.writeI32((int) (local1 + 16) < 0 ? (local1 + 16) : (local1 + 16) + 0, (int) local2); + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_28); + } + label_41: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local1 + 11) < 0 ? (local1 + 11) : (local1 + 11) + 0), -1) != 0) { + break label_41; + } + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 0)); + instance.getMachine().call(1777, callArgs_29); + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local1); + local1 = (local1 + -44); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_39; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 196); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 200, (int) local3); + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_30); + } + label_42: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 184); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_42; + } + memory.writeI32((int) (arg0 + 188) < 0 ? (arg0 + 188) : (arg0 + 188) + 0, (int) local1); + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_31); + } + label_43: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 172); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_43; + } + memory.writeI32((int) (arg0 + 176) < 0 ? (arg0 + 176) : (arg0 + 176) + 0, (int) local1); + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_32); + } + label_44: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 160); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_44; + } + memory.writeI32((int) (arg0 + 164) < 0 ? (arg0 + 164) : (arg0 + 164) + 0, (int) local1); + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_33); + } + label_45: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 148); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_45; + } + memory.writeI32((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0, (int) local1); + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_34); + } + label_46: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 136); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_46; + } + memory.writeI32((int) (arg0 + 140) < 0 ? (arg0 + 140) : (arg0 + 140) + 0, (int) local1); + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_35); + } + label_47: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_47; + } + memory.writeI32((int) (arg0 + 128) < 0 ? (arg0 + 128) : (arg0 + 128) + 0, (int) local1); + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_36); + } + label_48: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 112); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_48; + } + memory.writeI32((int) (arg0 + 116) < 0 ? (arg0 + 116) : (arg0 + 116) + 0, (int) local1); + long[] callArgs_37 = new long[1]; + callArgs_37[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_37); + } + label_49: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_49; + } + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) local1); + long[] callArgs_38 = new long[1]; + callArgs_38[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_38); + } + label_50: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_50; + } + memory.writeI32((int) (arg0 + 92) < 0 ? (arg0 + 92) : (arg0 + 92) + 0, (int) local1); + long[] callArgs_39 = new long[1]; + callArgs_39[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_39); + } + label_51: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_51; + } + memory.writeI32((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0, (int) local1); + long[] callArgs_40 = new long[1]; + callArgs_40[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_40); + } + label_52: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_52; + } + memory.writeI32((int) (arg0 + 68) < 0 ? (arg0 + 68) : (arg0 + 68) + 0, (int) local1); + long[] callArgs_41 = new long[1]; + callArgs_41[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_41); + } + label_53: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_53; + } + label_54: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_42 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_42 = instance.table(0).requiredRef(ciTableIdx_42); + com.dylibso.chicory.runtime.Instance ciRefInstance_42 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_42), instance); + if (!ciRefInstance_42.type(ciRefInstance_42.functionType(ciFuncId_42)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_42 = new long[1]; + callArgs_42[0] = ((long) local1); + ciRefInstance_42.getMachine().call(ciFuncId_42, callArgs_42); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_54; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 32, (long) 0L); + memory.writeI32((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (int) 0); + label_55: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 31), -1) != 0) { + break label_55; + } + long[] callArgs_43 = new long[1]; + callArgs_43[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)); + instance.getMachine().call(1777, callArgs_43); + } + return arg0; + } + + public static long[] call_32(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_32(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_33(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(21, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_33(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_33(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_34(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(34, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(34, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_2); + } + return; + } + + public static long[] call_34(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_34(arg0, arg1, memory, instance); + return null; + } + + public static void func_35(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeLong((int) 0 < 0 ? 0 : 0 + 621956, (long) 0L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621964, (int) 0); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 1024); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) 10); + long[] callResult_0 = instance.getMachine().call(1825, callArgs_0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 1024); + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) 11); + long[] callResult_1 = instance.getMachine().call(1825, callArgs_1); + return; + } + + public static long[] call_35(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_35(memory, instance); + return null; + } + + public static void func_36(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local2 < 0 ? local2 : local2 + 64) & 0xFF)) != 0) { + break label_2; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 + 8)); + callArgs_1[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_1); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 16, (byte) (((int) memory.read((int) local2 < 0 ? local2 : local2 + 64) & 0xFF))); + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) 0); + callArgs_2[3] = ((long) 1373); + callArgs_2[2] = ((long) 1); + callArgs_2[1] = ((long) (local2 + 16)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(224, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_3); + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 68); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 8)); + callArgs_4[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_4); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 16)); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(169, callArgs_5); + break label_1; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local2 + 8)); + callArgs_6[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_6); + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 68); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) (local2 + 8)); + callArgs_7[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_7); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 16); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 16, (byte) (arg1)); + long[] callArgs_8 = new long[5]; + callArgs_8[4] = ((long) 0); + callArgs_8[3] = ((long) local3); + callArgs_8[2] = ((long) 1); + callArgs_8[1] = ((long) (local2 + 16)); + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(224, callArgs_8); + } + instance.global(0).setValue(((long) (local2 + 80))); + return; + } + + public static long[] call_36(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_36(arg0, arg1, memory, instance); + return null; + } + + public static void func_37(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + local5 = (int) local4; + label_1: { + label_2: { + if (arg2 != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) local3); + instance.getMachine().call(38, callArgs_0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : local3)); + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(173, callArgs_1); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), -1) != 0) { + break label_3; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_2); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0) { + break label_1; + } + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + instance.getMachine().call(38, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : local3)); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(173, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), -1) != 0) { + break label_1; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_5); + break label_1; + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) arg2); + callArgs_6[1] = ((long) local5); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(173, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local5) != 0) { + break label_1; + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) arg2); + callArgs_7[1] = ((long) (int) (local4 >>> 32L)); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(173, callArgs_7); + } + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_37(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_37(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_38(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + label_13: { + label_14: { + label_15: { + label_16: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + switch((local3 + 64)) { + case 0: + { + break label_6; + } + case 1: + { + break label_2; + } + case 2: + { + break label_2; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_2; + } + case 6: + { + break label_2; + } + case 7: + { + break label_2; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_2; + } + case 19: + { + break label_2; + } + case 20: + { + break label_2; + } + case 21: + { + break label_2; + } + case 22: + { + break label_2; + } + case 23: + { + break label_2; + } + case 24: + { + break label_2; + } + case 25: + { + break label_2; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_2; + } + case 29: + { + break label_2; + } + case 30: + { + break label_2; + } + case 31: + { + break label_2; + } + case 32: + { + break label_7; + } + case 33: + { + break label_2; + } + case 34: + { + break label_2; + } + case 35: + { + break label_2; + } + case 36: + { + break label_2; + } + case 37: + { + break label_2; + } + case 38: + { + break label_2; + } + case 39: + { + break label_2; + } + case 40: + { + break label_2; + } + case 41: + { + break label_9; + } + case 42: + { + break label_2; + } + case 43: + { + break label_3; + } + case 44: + { + break label_2; + } + case 45: + { + break label_2; + } + case 46: + { + break label_2; + } + case 47: + { + break label_4; + } + case 48: + { + break label_8; + } + case 49: + { + break label_2; + } + case 50: + { + break label_2; + } + case 51: + { + break label_2; + } + case 52: + { + break label_2; + } + case 53: + { + break label_2; + } + case 54: + { + break label_2; + } + case 55: + { + break label_2; + } + case 56: + { + break label_2; + } + case 57: + { + break label_10; + } + case 58: + { + break label_11; + } + case 59: + { + break label_12; + } + case 60: + { + break label_13; + } + case 61: + { + break label_14; + } + case 62: + { + break label_15; + } + case 63: + { + break label_16; + } + case 64: + { + break label_5; + } + default: + { + break label_2; + } + } + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (3)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (0)); + memory.writeShort((int) arg0 < 0 ? arg0 : arg0 + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 28150) & 0xFFFF))); + memory.writeByte((int) (arg0 + 2) < 0 ? (arg0 + 2) : (arg0 + 2) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 28152) & 0xFF))); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (3)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (0)); + memory.writeShort((int) arg0 < 0 ? arg0 : arg0 + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 27818) & 0xFFFF))); + memory.writeByte((int) (arg0 + 2) < 0 ? (arg0 + 2) : (arg0 + 2) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 27820) & 0xFF))); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (3)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (0)); + memory.writeShort((int) arg0 < 0 ? arg0 : arg0 + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 28186) & 0xFFFF))); + memory.writeByte((int) (arg0 + 2) < 0 ? (arg0 + 2) : (arg0 + 2) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 28188) & 0xFF))); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (3)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (0)); + memory.writeShort((int) arg0 < 0 ? arg0 : arg0 + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 27853) & 0xFFFF))); + memory.writeByte((int) (arg0 + 2) < 0 ? (arg0 + 2) : (arg0 + 2) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 27855) & 0xFF))); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 4, (byte) (0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 942813558); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (4)); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 2, (byte) (0)); + memory.writeShort((int) arg0 < 0 ? arg0 : arg0 + 0, (short) (14441)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (2)); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (3)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (0)); + memory.writeShort((int) arg0 < 0 ? arg0 : arg0 + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 27656) & 0xFFFF))); + memory.writeByte((int) (arg0 + 2) < 0 ? (arg0 + 2) : (arg0 + 2) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 27658) & 0xFF))); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (6)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 6, (byte) (0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 14812)); + memory.writeShort((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 14816) & 0xFFFF))); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (7)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 7, (byte) (0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 14829)); + memory.writeI32((int) (arg0 + 3) < 0 ? (arg0 + 3) : (arg0 + 3) + 0, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 14832)); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 4, (byte) (0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 1668183398); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (4)); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 4, (byte) (0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 1684631414); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (4)); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (3)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (0)); + memory.writeShort((int) arg0 < 0 ? arg0 : arg0 + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 1271) & 0xFFFF))); + memory.writeByte((int) (arg0 + 2) < 0 ? (arg0 + 2) : (arg0 + 2) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 1273) & 0xFF))); + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (9)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 9, (byte) (0)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 14819)); + memory.writeByte((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 14827) & 0xFF))); + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local2 + 16)); + callArgs_0[1] = ((long) 30506); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(39, callArgs_0); + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local3); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) 27499); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(39, callArgs_1); + } + instance.global(0).setValue(((long) (local2 + 32))); + return; + } + + public static long[] call_38(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_38(arg0, arg1, memory, instance); + return null; + } + + public static void func_39(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg2); + local4 = 0; + label_1: { + label_2: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) 0); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg2 = ((int) callResult_0[0]); + local5 = (arg2 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg2, -2) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local5); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 8)); + callArgs_3[2] = ((long) arg1); + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = instance.getMachine().call(1875, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 2147483632) != 0) { + break label_1; + } + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 10) != 0) { + break label_4; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (arg2)); + break label_3; + } + local5 = ((arg2 | 15) + 1); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg1 = ((int) callResult_4[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local5 | -2147483648)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + arg0 = arg1; + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1890, callArgs_5); + memory.writeByte((int) (((int) callResult_5[0]) + arg2) < 0 ? (((int) callResult_5[0]) + arg2) : (((int) callResult_5[0]) + arg2) + 0, (byte) (0)); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_5; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_6); + } + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_39(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_39(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_40(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local3 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local3)); + local4 = (local3 + 72); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeLong((int) ((local3 + 8) + 20) < 0 ? ((local3 + 8) + 20) : ((local3 + 8) + 20) + 0, (long) 0L); + memory.writeLong((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (long) 0L); + memory.writeLong((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (long) 0L); + memory.writeLong((int) (local3 + 52) < 0 ? (local3 + 52) : (local3 + 52) + 0, (long) 0L); + memory.writeLong((int) (local3 + 60) < 0 ? (local3 + 60) : (local3 + 60) + 0, (long) 0L); + local5 = (local3 + 68); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local4); + memory.writeLong((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0, (long) 0L); + memory.writeLong((int) (local3 + 96) < 0 ? (local3 + 96) : (local3 + 96) + 0, (long) 0L); + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) -4294967296L); + local4 = (local3 + 152); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeLong((int) (local3 + 120) < 0 ? (local3 + 120) : (local3 + 120) + 0, (long) 0L); + memory.writeLong((int) (local3 + 128) < 0 ? (local3 + 128) : (local3 + 128) + 0, (long) 0L); + memory.writeLong((int) (local3 + 133) < 0 ? (local3 + 133) : (local3 + 133) + 0, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 20, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 80, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 144, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 112, (long) 0L); + memory.writeI32((int) (local3 + 160) < 0 ? (local3 + 160) : (local3 + 160) + 0, (int) 1065353216); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(41, callArgs_0); + local6 = ((int) callResult_0[0]); + label_1: { + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_1; + } + label_2: while (true) { + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + label_3: { + local9 = memory.readInt((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_3; + } + arg2 = local9; + label_4: { + arg1 = memory.readInt((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_4; + } + label_5: while (true) { + label_6: { + local4 = (arg1 + -16); + local10 = (local4 + 4); + arg0 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_6; + } + arg2 = arg0; + label_7: { + local11 = (arg1 + -8); + arg1 = memory.readInt((int) local11 < 0 ? local11 : local11 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, arg1) != 0) { + break label_7; + } + arg1 = (arg1 + -12); + label_8: while (true) { + label_9: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_9; + } + memory.writeI32((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0, (int) arg2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_1); + } + arg2 = (arg1 + -4); + arg1 = (arg1 + -16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg0, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + arg2 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) arg0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_2); + } + arg1 = local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + arg2 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 20, (int) local9); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_3); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_4); + local7 = local8; + if (local8 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 144); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 144, (int) 0); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_10; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_5); + } + label_11: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 80); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_11; + } + arg1 = arg0; + label_12: { + arg2 = memory.readInt((int) (local3 + 84) < 0 ? (local3 + 84) : (local3 + 84) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, arg2) != 0) { + break label_12; + } + arg1 = (arg2 + -12); + label_13: while (true) { + label_14: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_14; + } + memory.writeI32((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0, (int) arg2); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_6); + } + arg2 = (arg1 + -8); + arg1 = (arg1 + -20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg0, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break; + } + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 80); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 84, (int) arg0); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_7); + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 72)); + callArgs_8[0] = ((long) local5); + instance.getMachine().call(42, callArgs_8); + label_15: { + arg1 = memory.readInt((int) (local3 + 56) < 0 ? (local3 + 56) : (local3 + 56) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_15; + } + memory.writeI32((int) (local3 + 60) < 0 ? (local3 + 60) : (local3 + 60) + 0, (int) arg1); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_9); + } + label_16: { + arg1 = memory.readInt((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_16; + } + memory.writeI32((int) (local3 + 48) < 0 ? (local3 + 48) : (local3 + 48) + 0, (int) arg1); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_10); + } + label_17: { + arg1 = memory.readInt((int) (local3 + 32) < 0 ? (local3 + 32) : (local3 + 32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_17; + } + memory.writeI32((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (int) arg1); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_11); + } + label_18: { + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_18; + } + memory.writeI32((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (int) arg1); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_12); + } + instance.global(0).setValue(((long) (local3 + 176))); + return local6; + } + + public static long[] call_40(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_40(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_41(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[40]; + long[] lL = new long[2]; + iL[0] = arg0; + iL[23] = (((int) instance.global(0).getValue()) - 688); + instance.global(0).setValue(((long) iL[23])); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 1836278016); + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 27160); + callArgs_0[2] = ((long) 4); + callArgs_0[1] = ((long) (iL[23] + 560)); + callArgs_0[0] = ((long) iL[24]); + instance.getMachine().call(224, callArgs_0); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 1); + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 27014); + callArgs_1[2] = ((long) 4); + callArgs_1[1] = ((long) (iL[23] + 560)); + callArgs_1[0] = ((long) iL[24]); + instance.getMachine().call(224, callArgs_1); + label_1: { + label_2: { + label_3: { + int _d1 = func_41__h1(iL, lL, memory, instance); + if (_d1 == 1) + break label_1; + if (_d1 == 2) + break label_2; + } + label_92: { + int _d4 = func_41__h4(iL, lL, memory, instance); + } + label_112: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 100), memory.readInt((int) (iL[24] + 104) < 0 ? (iL[24] + 104) : (iL[24] + 104) + 0)) != 0) { + break label_112; + } + long[] callArgs_65 = new long[2]; + callArgs_65[1] = ((long) 2); + callArgs_65[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_65); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + long[] callArgs_66 = new long[3]; + callArgs_66[2] = ((long) 7694); + callArgs_66[1] = ((long) ((memory.readInt((int) (iL[24] + 104) < 0 ? (iL[24] + 104) : (iL[24] + 104) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 100)) >> 2)); + callArgs_66[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_66); + label_113: { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[17] = iL[24]; + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 100); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[24], memory.readInt((int) (iL[17] + 104) < 0 ? (iL[17] + 104) : (iL[17] + 104) + 0)) != 0) { + break label_113; + } + iL[38] = 0; + iL[36] = 0; + label_114: while (true) { + iL[24] = memory.readInt((int) (iL[24] + iL[38]) < 0 ? (iL[24] + iL[38]) : (iL[24] + iL[38]) + 0); + label_115: { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = memory.readInt((int) (iL[37] + 12) < 0 ? (iL[37] + 12) : (iL[37] + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[30]) != 0) { + break label_115; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 308, (int) iL[36]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 304, (int) 11702); + long[] callArgs_67 = new long[3]; + callArgs_67[2] = ((long) (iL[23] + 304)); + callArgs_67[1] = ((long) 32371); + callArgs_67[0] = ((long) iL[30]); + instance.getMachine().call(223, callArgs_67); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + } + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + iL[25] = ((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 15) & 0xFF); + iL[16] = iL[25]; + iL[25] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[25]), 0); + iL[31] = (iL[25] != 0 ? memory.readInt((int) (iL[24] + 8) < 0 ? (iL[24] + 8) : (iL[24] + 8) + 0) : iL[16]); + long[] callArgs_68 = new long[3]; + callArgs_68[2] = ((long) 14225); + callArgs_68[1] = ((long) iL[31]); + callArgs_68[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_68); + long[] callArgs_69 = new long[5]; + callArgs_69[4] = ((long) 1); + callArgs_69[3] = ((long) 16931); + callArgs_69[2] = ((long) iL[31]); + callArgs_69[1] = ((long) (iL[25] != 0 ? iL[30] : (iL[24] + 4))); + callArgs_69[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_69); + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 16); + iL[30] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[25] = ((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 27) & 0xFF); + iL[15] = iL[25]; + iL[25] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[25]), 0); + iL[31] = (iL[25] != 0 ? memory.readInt((int) (iL[24] + 20) < 0 ? (iL[24] + 20) : (iL[24] + 20) + 0) : iL[15]); + long[] callArgs_70 = new long[3]; + callArgs_70[2] = ((long) 14225); + callArgs_70[1] = ((long) iL[31]); + callArgs_70[0] = ((long) iL[30]); + instance.getMachine().call(169, callArgs_70); + long[] callArgs_71 = new long[5]; + callArgs_71[4] = ((long) 1); + callArgs_71[3] = ((long) 16961); + callArgs_71[2] = ((long) iL[31]); + callArgs_71[1] = ((long) (iL[25] != 0 ? iL[37] : (iL[24] + 16))); + callArgs_71[0] = ((long) iL[30]); + instance.getMachine().call(224, callArgs_71); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 28))); + long[] callArgs_72 = new long[5]; + callArgs_72[4] = ((long) 0); + callArgs_72[3] = ((long) 17665); + callArgs_72[2] = ((long) 1); + callArgs_72[1] = ((long) (iL[23] + 560)); + callArgs_72[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_72); + label_116: { + label_117: { + label_118: { + label_119: { + label_120: { + label_121: { + switch(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 28)) { + case 0: + { + break label_121; + } + case 1: + { + break label_120; + } + case 2: + { + break label_119; + } + case 3: + { + break label_118; + } + case 4: + { + break label_117; + } + default: + { + break label_116; + } + } + } + long[] callArgs_73 = new long[2]; + callArgs_73[1] = ((long) (iL[24] + 44)); + callArgs_73[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_73 = instance.getMachine().call(135, callArgs_73); + long[] callArgs_74 = new long[3]; + callArgs_74[2] = ((long) 1792); + callArgs_74[1] = ((long) ((int) callResult_73[0])); + callArgs_74[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_74); + break label_116; + } + long[] callArgs_75 = new long[2]; + callArgs_75[1] = ((long) (iL[24] + 32)); + callArgs_75[0] = ((long) iL[0]); + instance.getMachine().call(49, callArgs_75); + break label_116; + } + long[] callArgs_76 = new long[2]; + callArgs_76[1] = ((long) (iL[24] + 32)); + callArgs_76[0] = ((long) iL[0]); + instance.getMachine().call(50, callArgs_76); + break label_116; + } + lL[0] = memory.readLong((int) (iL[24] + 44) < 0 ? (iL[24] + 44) : (iL[24] + 44) + 0); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (long) lL[0]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 296, (long) lL[0]); + long[] callArgs_77 = new long[3]; + callArgs_77[2] = ((long) 0); + callArgs_77[1] = ((long) (iL[23] + 296)); + callArgs_77[0] = ((long) iL[37]); + instance.getMachine().call(37, callArgs_77); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 384, (byte) (((int) memory.read((int) (iL[24] + 52) < 0 ? (iL[24] + 52) : (iL[24] + 52) + 0) & 0xFF))); + long[] callArgs_78 = new long[5]; + callArgs_78[4] = ((long) 0); + callArgs_78[3] = ((long) 1083); + callArgs_78[2] = ((long) 1); + callArgs_78[1] = ((long) (iL[23] + 384)); + callArgs_78[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_78); + break label_116; + } + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (0)); + long[] callArgs_79 = new long[5]; + callArgs_79[4] = ((long) 0); + callArgs_79[3] = ((long) 15538); + callArgs_79[2] = ((long) 1); + callArgs_79[1] = ((long) (iL[23] + 560)); + callArgs_79[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_79); + long[] callArgs_80 = new long[2]; + callArgs_80[1] = ((long) (iL[24] + 44)); + callArgs_80[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_80 = instance.getMachine().call(135, callArgs_80); + long[] callArgs_81 = new long[3]; + callArgs_81[2] = ((long) 1870); + callArgs_81[1] = ((long) ((int) callResult_80[0])); + callArgs_81[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_81); + } + iL[38] = (iL[38] + 4); + iL[36] = (iL[36] + 1); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[14] = iL[24]; + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 100); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[36], ((memory.readInt((int) (iL[14] + 104) < 0 ? (iL[14] + 104) : (iL[14] + 104) + 0) - iL[24]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_114; + } + break; + } + } + long[] callArgs_82 = new long[4]; + callArgs_82[3] = ((long) 15012); + callArgs_82[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_82[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_82[0] = ((long) iL[0]); + long[] callResult_82 = instance.getMachine().call(48, callArgs_82); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + iL[37] = ((memory.readInt((int) (iL[24] + 80) < 0 ? (iL[24] + 80) : (iL[24] + 80) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 76)) >> 2); + iL[38] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 48); + iL[26] = (iL[37] - iL[38]); + label_122: { + iL[27] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[37]); + if (iL[27] != 0) { + break label_122; + } + long[] callArgs_83 = new long[2]; + callArgs_83[1] = ((long) 3); + callArgs_83[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_83); + long[] callArgs_84 = new long[3]; + callArgs_84[2] = ((long) 7922); + callArgs_84[1] = ((long) iL[26]); + callArgs_84[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_84); + iL[24] = 0; + label_123: while (true) { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[37] = memory.readInt((int) (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 76) + ((iL[24] + memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 48)) << 2)) < 0 ? (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 76) + ((iL[24] + memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 48)) << 2)) : (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 76) + ((iL[24] + memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 48)) << 2)) + 0); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 288, (int) iL[24]); + long[] callArgs_85 = new long[4]; + callArgs_85[3] = ((long) (iL[23] + 288)); + callArgs_85[2] = ((long) 1890); + callArgs_85[1] = ((long) 100); + callArgs_85[0] = ((long) (iL[23] + 560)); + long[] callResult_85 = instance.getMachine().call(1865, callArgs_85); + long[] callArgs_86 = new long[2]; + callArgs_86[1] = ((long) (iL[37] + 12)); + callArgs_86[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_86 = instance.getMachine().call(135, callArgs_86); + long[] callArgs_87 = new long[3]; + callArgs_87[2] = ((long) (iL[23] + 560)); + callArgs_87[1] = ((long) ((int) callResult_86[0])); + callArgs_87[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_87); + iL[24] = (iL[24] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[24], iL[26]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_123; + } + break; + } + long[] callArgs_88 = new long[4]; + callArgs_88[3] = ((long) 15012); + callArgs_88[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_88[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_88[0] = ((long) iL[0]); + long[] callResult_88 = instance.getMachine().call(48, callArgs_88); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_124: { + iL[37] = ((memory.readInt((int) (iL[24] + 140) < 0 ? (iL[24] + 140) : (iL[24] + 140) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 136)) >> 2); + iL[38] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[37]) != 0) { + break label_124; + } + long[] callArgs_89 = new long[2]; + callArgs_89[1] = ((long) 4); + callArgs_89[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_89); + iL[36] = (iL[37] - iL[38]); + long[] callArgs_90 = new long[3]; + callArgs_90[2] = ((long) 8637); + callArgs_90[1] = ((long) iL[36]); + callArgs_90[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_90); + iL[24] = 0; + label_125: while (true) { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[37] = memory.readInt((int) (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 136) + ((iL[24] + memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 52)) << 2)) < 0 ? (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 136) + ((iL[24] + memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 52)) << 2)) : (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 136) + ((iL[24] + memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 52)) << 2)) + 0); + label_126: { + iL[38] = memory.readInt((int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) < 0 ? (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) : (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_126; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 276, (int) iL[24]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 272, (int) 17326); + long[] callArgs_91 = new long[3]; + callArgs_91[2] = ((long) (iL[23] + 272)); + callArgs_91[1] = ((long) 32371); + callArgs_91[0] = ((long) iL[38]); + instance.getMachine().call(223, callArgs_91); + } + long[] callArgs_92 = new long[2]; + callArgs_92[1] = ((long) iL[37]); + callArgs_92[0] = ((long) iL[0]); + instance.getMachine().call(49, callArgs_92); + iL[24] = (iL[24] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[24], iL[36]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_125; + } + break; + } + long[] callArgs_93 = new long[4]; + callArgs_93[3] = ((long) 15012); + callArgs_93[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_93[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_93[0] = ((long) iL[0]); + long[] callResult_93 = instance.getMachine().call(48, callArgs_93); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_127: { + iL[37] = ((memory.readInt((int) (iL[24] + 164) < 0 ? (iL[24] + 164) : (iL[24] + 164) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 160)) >> 2); + iL[38] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[37]) != 0) { + break label_127; + } + long[] callArgs_94 = new long[2]; + callArgs_94[1] = ((long) 5); + callArgs_94[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_94); + iL[36] = (iL[37] - iL[38]); + long[] callArgs_95 = new long[3]; + callArgs_95[2] = ((long) 8648); + callArgs_95[1] = ((long) iL[36]); + callArgs_95[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_95); + iL[24] = 0; + label_128: while (true) { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[37] = memory.readInt((int) (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 160) + ((iL[24] + memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 56)) << 2)) < 0 ? (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 160) + ((iL[24] + memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 56)) << 2)) : (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 160) + ((iL[24] + memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 56)) << 2)) + 0); + label_129: { + iL[38] = memory.readInt((int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) < 0 ? (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) : (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_129; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 260, (int) iL[24]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 256, (int) 1196); + long[] callArgs_96 = new long[3]; + callArgs_96[2] = ((long) (iL[23] + 256)); + callArgs_96[1] = ((long) 32371); + callArgs_96[0] = ((long) iL[38]); + instance.getMachine().call(223, callArgs_96); + } + long[] callArgs_97 = new long[2]; + callArgs_97[1] = ((long) iL[37]); + callArgs_97[0] = ((long) iL[0]); + instance.getMachine().call(50, callArgs_97); + iL[24] = (iL[24] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[24], iL[36]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_128; + } + break; + } + long[] callArgs_98 = new long[4]; + callArgs_98[3] = ((long) 15012); + callArgs_98[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_98[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_98[0] = ((long) iL[0]); + long[] callResult_98 = instance.getMachine().call(48, callArgs_98); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_130: { + iL[37] = ((memory.readInt((int) (iL[24] + 68) < 0 ? (iL[24] + 68) : (iL[24] + 68) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 64)) >> 2); + iL[38] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[37]) != 0) { + break label_130; + } + long[] callArgs_99 = new long[2]; + callArgs_99[1] = ((long) 13); + callArgs_99[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_99); + iL[36] = (iL[37] - iL[38]); + long[] callArgs_100 = new long[3]; + callArgs_100[2] = ((long) 6543); + callArgs_100[1] = ((long) iL[36]); + callArgs_100[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_100); + iL[24] = 0; + label_131: while (true) { + label_132: { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[38] = memory.readInt((int) (iL[37] + 12) < 0 ? (iL[37] + 12) : (iL[37] + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_132; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 244, (int) iL[24]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 240, (int) 14710); + long[] callArgs_101 = new long[3]; + callArgs_101[2] = ((long) (iL[23] + 240)); + callArgs_101[1] = ((long) 32371); + callArgs_101[0] = ((long) iL[38]); + instance.getMachine().call(223, callArgs_101); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + } + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[38] = memory.readInt((int) (memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 64) + ((iL[24] + memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 44)) << 2)) < 0 ? (memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 64) + ((iL[24] + memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 44)) << 2)) : (memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 64) + ((iL[24] + memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 44)) << 2)) + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (0)); + long[] callArgs_102 = new long[5]; + callArgs_102[4] = ((long) 0); + callArgs_102[3] = ((long) 15538); + callArgs_102[2] = ((long) 1); + callArgs_102[1] = ((long) (iL[23] + 560)); + callArgs_102[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_102); + long[] callArgs_103 = new long[2]; + callArgs_103[1] = ((long) (iL[38] + 12)); + callArgs_103[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_103 = instance.getMachine().call(135, callArgs_103); + long[] callArgs_104 = new long[3]; + callArgs_104[2] = ((long) 1870); + callArgs_104[1] = ((long) ((int) callResult_103[0])); + callArgs_104[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_104); + iL[24] = (iL[24] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[24], iL[36]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_131; + } + break; + } + long[] callArgs_105 = new long[4]; + callArgs_105[3] = ((long) 15012); + callArgs_105[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_105[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_105[0] = ((long) iL[0]); + long[] callResult_105 = instance.getMachine().call(48, callArgs_105); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_133: { + iL[37] = ((memory.readInt((int) (iL[24] + 92) < 0 ? (iL[24] + 92) : (iL[24] + 92) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 88)) >> 2); + iL[38] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[37]) != 0) { + break label_133; + } + long[] callArgs_106 = new long[2]; + callArgs_106[1] = ((long) 6); + callArgs_106[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_106); + iL[36] = (iL[37] - iL[38]); + long[] callArgs_107 = new long[3]; + callArgs_107[2] = ((long) 8185); + callArgs_107[1] = ((long) iL[36]); + callArgs_107[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_107); + iL[37] = 0; + label_134: while (true) { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[24] = memory.readInt((int) (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 88) + ((memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 60) + iL[37]) << 2)) < 0 ? (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 88) + ((memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 60) + iL[37]) << 2)) : (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 88) + ((memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 60) + iL[37]) << 2)) + 0); + lL[0] = memory.readLong((int) iL[24] < 0 ? iL[24] : iL[24] + 12); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (long) lL[0]); + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 232, (long) lL[0]); + long[] callArgs_108 = new long[3]; + callArgs_108[2] = ((long) 0); + callArgs_108[1] = ((long) (iL[23] + 232)); + callArgs_108[0] = ((long) iL[38]); + instance.getMachine().call(37, callArgs_108); + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 384, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 20) & 0xFF))); + long[] callArgs_109 = new long[5]; + callArgs_109[4] = ((long) 0); + callArgs_109[3] = ((long) 1083); + callArgs_109[2] = ((long) 1); + callArgs_109[1] = ((long) (iL[23] + 384)); + callArgs_109[0] = ((long) iL[38]); + instance.getMachine().call(224, callArgs_109); + label_135: { + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_135; + } + label_136: while (true) { + long[] callArgs_110 = new long[3]; + callArgs_110[2] = ((long) iL[24]); + callArgs_110[1] = ((long) 0); + callArgs_110[0] = ((long) iL[0]); + instance.getMachine().call(51, callArgs_110); + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + if (iL[24] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_136; + } + break; + } + } + long[] callArgs_111 = new long[2]; + callArgs_111[1] = ((long) 11); + callArgs_111[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_111); + iL[37] = (iL[37] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_134; + } + break; + } + long[] callArgs_112 = new long[4]; + callArgs_112[3] = ((long) 15012); + callArgs_112[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_112[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_112[0] = ((long) iL[0]); + long[] callResult_112 = instance.getMachine().call(48, callArgs_112); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_137: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 112), memory.readInt((int) (iL[24] + 116) < 0 ? (iL[24] + 116) : (iL[24] + 116) + 0)) != 0) { + break label_137; + } + long[] callArgs_113 = new long[2]; + callArgs_113[1] = ((long) 7); + callArgs_113[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_113); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + long[] callArgs_114 = new long[3]; + callArgs_114[2] = ((long) 7682); + callArgs_114[1] = ((long) ((memory.readInt((int) (iL[24] + 116) < 0 ? (iL[24] + 116) : (iL[24] + 116) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 112)) >> 2)); + callArgs_114[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_114); + label_138: { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 112); + iL[31] = memory.readInt((int) (iL[24] + 116) < 0 ? (iL[24] + 116) : (iL[24] + 116) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[31], iL[37]) != 0) { + break label_138; + } + label_139: while (true) { + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[38] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + iL[36] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = ((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 11) & 0xFF); + iL[13] = iL[30]; + iL[30] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[30]), 0); + iL[25] = (iL[30] != 0 ? memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4) : iL[13]); + long[] callArgs_115 = new long[3]; + callArgs_115[2] = ((long) 14225); + callArgs_115[1] = ((long) iL[25]); + callArgs_115[0] = ((long) iL[36]); + instance.getMachine().call(169, callArgs_115); + long[] callArgs_116 = new long[5]; + callArgs_116[4] = ((long) 1); + callArgs_116[3] = ((long) 16797); + callArgs_116[2] = ((long) iL[25]); + callArgs_116[1] = ((long) (iL[30] != 0 ? iL[38] : iL[24])); + callArgs_116[0] = ((long) iL[36]); + instance.getMachine().call(224, callArgs_116); + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 12))); + long[] callArgs_117 = new long[5]; + callArgs_117[4] = ((long) 0); + callArgs_117[3] = ((long) 17653); + callArgs_117[2] = ((long) 1); + callArgs_117[1] = ((long) (iL[23] + 560)); + callArgs_117[0] = ((long) iL[38]); + instance.getMachine().call(224, callArgs_117); + label_140: { + label_141: { + label_142: { + label_143: { + label_144: { + label_145: { + switch(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 12)) { + case 0: + { + break label_145; + } + case 1: + { + break label_144; + } + case 2: + { + break label_143; + } + case 3: + { + break label_142; + } + case 4: + { + break label_141; + } + default: + { + break label_140; + } + } + } + long[] callArgs_118 = new long[2]; + callArgs_118[1] = ((long) (iL[24] + 16)); + callArgs_118[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_118 = instance.getMachine().call(121, callArgs_118); + iL[24] = ((int) callResult_118[0]); + long[] callArgs_119 = new long[3]; + callArgs_119[2] = ((long) 2154); + callArgs_119[1] = ((long) iL[24]); + callArgs_119[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_119); + break label_140; + } + long[] callArgs_120 = new long[2]; + callArgs_120[1] = ((long) (iL[24] + 16)); + callArgs_120[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_120 = instance.getMachine().call(123, callArgs_120); + iL[24] = ((int) callResult_120[0]); + long[] callArgs_121 = new long[3]; + callArgs_121[2] = ((long) 1942); + callArgs_121[1] = ((long) iL[24]); + callArgs_121[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_121); + break label_140; + } + long[] callArgs_122 = new long[2]; + callArgs_122[1] = ((long) (iL[24] + 16)); + callArgs_122[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_122 = instance.getMachine().call(124, callArgs_122); + iL[24] = ((int) callResult_122[0]); + long[] callArgs_123 = new long[3]; + callArgs_123[2] = ((long) 1405); + callArgs_123[1] = ((long) iL[24]); + callArgs_123[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_123); + break label_140; + } + long[] callArgs_124 = new long[2]; + callArgs_124[1] = ((long) (iL[24] + 16)); + callArgs_124[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_124 = instance.getMachine().call(122, callArgs_124); + iL[24] = ((int) callResult_124[0]); + long[] callArgs_125 = new long[3]; + callArgs_125[2] = ((long) 1707); + callArgs_125[1] = ((long) iL[24]); + callArgs_125[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_125); + break label_140; + } + long[] callArgs_126 = new long[2]; + callArgs_126[1] = ((long) (iL[24] + 16)); + callArgs_126[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_126 = instance.getMachine().call(126, callArgs_126); + iL[24] = ((int) callResult_126[0]); + long[] callArgs_127 = new long[3]; + callArgs_127[2] = ((long) 1775); + callArgs_127[1] = ((long) iL[24]); + callArgs_127[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_127); + } + iL[37] = (iL[37] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[31], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_139; + } + break; + } + } + long[] callArgs_128 = new long[4]; + callArgs_128[3] = ((long) 15012); + callArgs_128[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_128[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_128[0] = ((long) iL[0]); + long[] callResult_128 = instance.getMachine().call(48, callArgs_128); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_146: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 184); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[37], memory.readInt((int) (iL[24] + 188) < 0 ? (iL[24] + 188) : (iL[24] + 188) + 0)) != 0) { + break label_146; + } + long[] callArgs_129 = new long[2]; + callArgs_129[1] = ((long) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0)); + callArgs_129[0] = ((long) iL[24]); + long[] callResult_129 = instance.getMachine().call(121, callArgs_129); + iL[24] = ((int) callResult_129[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[24]) != 0) { + break label_146; + } + long[] callArgs_130 = new long[2]; + callArgs_130[1] = ((long) 8); + callArgs_130[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_130); + long[] callArgs_131 = new long[3]; + callArgs_131[2] = ((long) 2172); + callArgs_131[1] = ((long) iL[24]); + callArgs_131[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_131); + long[] callArgs_132 = new long[4]; + callArgs_132[3] = ((long) 15012); + callArgs_132[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_132[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_132[0] = ((long) iL[0]); + long[] callResult_132 = instance.getMachine().call(48, callArgs_132); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + } + label_147: { + int _d5 = func_41__h5(iL, lL, memory, instance); + } + label_165: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) < 0 ? memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) : memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 9) & 0xFF)) != 0) { + break label_165; + } + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 172), memory.readInt((int) (iL[24] + 176) < 0 ? (iL[24] + 176) : (iL[24] + 176) + 0)) != 0) { + break label_165; + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 124, (int) memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + long[] callArgs_159 = new long[2]; + callArgs_159[1] = ((long) 12); + callArgs_159[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_159); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + long[] callArgs_160 = new long[3]; + callArgs_160[2] = ((long) 6678); + callArgs_160[1] = ((long) ((memory.readInt((int) (iL[24] + 176) < 0 ? (iL[24] + 176) : (iL[24] + 176) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 172)) >> 2)); + callArgs_160[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_160); + long[] callArgs_161 = new long[4]; + callArgs_161[3] = ((long) 15012); + callArgs_161[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_161[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_161[0] = ((long) iL[0]); + long[] callResult_161 = instance.getMachine().call(48, callArgs_161); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 128, (int) memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + } + label_166: { + int _d9 = func_41__h9(iL, lL, memory, instance); + } + label_179: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) < 0 ? memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) : memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 9) & 0xFF)) != 0) { + break label_179; + } + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 172), memory.readInt((int) (iL[24] + 176) < 0 ? (iL[24] + 176) : (iL[24] + 176) + 0)) != 0) { + break label_179; + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 132) & 0xFF) & 255) != 0) { + break label_179; + } + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 128); + iL[36] = (iL[30] - iL[38]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 124); + label_180: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[30]) != 0) { + break label_180; + } + long[] callArgs_180 = new long[4]; + callArgs_180[3] = ((long) iL[36]); + callArgs_180[2] = ((long) iL[38]); + callArgs_180[1] = ((long) iL[37]); + callArgs_180[0] = ((long) iL[24]); + instance.getMachine().call(225, callArgs_180); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 124); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 120, (int) iL[37]); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + } + long[] callArgs_181 = new long[2]; + callArgs_181[1] = ((long) (iL[37] + iL[36])); + callArgs_181[0] = ((long) iL[24]); + instance.getMachine().call(226, callArgs_181); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88); + iL[38] = (iL[37] + -1); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) iL[38]); + iL[24] = memory.readInt((int) (iL[0] + 72) < 0 ? (iL[0] + 72) : (iL[0] + 72) + 0); + iL[36] = memory.readInt((int) (iL[0] + 76) < 0 ? (iL[0] + 76) : (iL[0] + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_179; + } + iL[30] = (iL[37] + -2); + label_181: while (true) { + label_182: { + iL[37] = (iL[24] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[38], memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0)) != 0) { + break label_182; + } + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (int) iL[30]); + } + iL[24] = (iL[24] + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_181; + } + break; + } + } + label_183: { + int _d7 = func_41__h7(iL, lL, memory, instance); + } + label_198: { + int _d8 = func_41__h8(iL, lL, memory, instance); + if (_d8 == 1) + break label_1; + } + label_214: { + int _d6 = func_41__h6(iL, lL, memory, instance); + if (_d6 == 1) + break label_1; + } + label_236: { + int _d0 = func_41__h0(iL, lL, memory, instance); + } + label_293: { + int _d2 = func_41__h2(iL, lL, memory, instance); + } + iL[24] = memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 8); + } + instance.global(0).setValue(((long) (iL[23] + 688))); + return iL[24]; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_41(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_41(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_42(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(42, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(42, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_2); + } + return; + } + + public static long[] call_42(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_42(arg0, arg1, memory, instance); + return null; + } + + public static void func_43(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, arg1); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 12, (byte) (local2)); + label_1: { + if (local2 != 0) { + break label_1; + } + label_2: while (true) { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + if (((int) memory.read((int) local3 < 0 ? local3 : local3 + 12) & 0xFF) != 0) { + break label_1; + } + label_3: { + label_4: { + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local4) != 0) { + break label_4; + } + label_5: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_5; + } + if (((int) memory.read((int) local4 < 0 ? local4 : local4 + 12) & 0xFF) != 0) { + break label_5; + } + local4 = (local4 + 12); + break label_3; + } + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, memory.readInt((int) local3 < 0 ? local3 : local3 + 0)) != 0) { + break label_7; + } + local4 = local3; + break label_6; + } + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + arg1 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg1); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_8; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local3); + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local2); + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + memory.writeI32((int) (local2 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, memory.readInt((int) local2 < 0 ? local2 : local2 + 0)) << 2)) < 0 ? (local2 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, memory.readInt((int) local2 < 0 ? local2 : local2 + 0)) << 2)) : (local2 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, memory.readInt((int) local2 < 0 ? local2 : local2 + 0)) << 2)) + 0, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + local2 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 12, (byte) (1)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 12, (byte) (0)); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local4); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_9; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local2); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + memory.writeI32((int) (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, memory.readInt((int) local4 < 0 ? local4 : local4 + 0)) << 2)) < 0 ? (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, memory.readInt((int) local4 < 0 ? local4 : local4 + 0)) << 2)) : (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, memory.readInt((int) local4 < 0 ? local4 : local4 + 0)) << 2)) + 0, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local2); + return; + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_10; + } + if (((int) memory.read((int) local4 < 0 ? local4 : local4 + 12) & 0xFF) != 0) { + break label_10; + } + local4 = (local4 + 12); + break label_3; + } + label_11: { + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, memory.readInt((int) local3 < 0 ? local3 : local3 + 0)) != 0) { + break label_12; + } + arg1 = local3; + break label_11; + } + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local4); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_13; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local3); + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local2); + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + memory.writeI32((int) (local2 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, memory.readInt((int) local2 < 0 ? local2 : local2 + 0)) << 2)) < 0 ? (local2 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, memory.readInt((int) local2 < 0 ? local2 : local2 + 0)) << 2)) : (local2 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, memory.readInt((int) local2 < 0 ? local2 : local2 + 0)) << 2)) + 0, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local3); + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 12, (byte) (1)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 12, (byte) (0)); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local4); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_14; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local2); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + memory.writeI32((int) (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, memory.readInt((int) local4 < 0 ? local4 : local4 + 0)) << 2)) < 0 ? (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, memory.readInt((int) local4 < 0 ? local4 : local4 + 0)) << 2)) : (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, memory.readInt((int) local4 < 0 ? local4 : local4 + 0)) << 2)) + 0, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local2); + break label_1; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 12, (byte) (1)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 12, (byte) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, local2))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (1)); + arg1 = local2; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg0, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + return; + } + + public static long[] call_43(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_43(arg0, arg1, memory, instance); + return null; + } + + public static int func_44(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + local5 = (int) (local4 >>> 32L); + local6 = (int) local4; + label_4: while (true) { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 16); + local7 = (int) (local4 >>> 32L); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, local5); + local9 = (local8 != 0 ? local7 : local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_11; + } + local10 = (int) local4; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local9); + callArgs_0[1] = ((long) local10); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1889, callArgs_0); + local11 = ((int) callResult_0[0]); + if (local11 != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local7) != 0) { + break label_9; + } + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local7) != 0) { + break label_8; + } + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local11, 0) != 0) { + break label_5; + } + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local9); + callArgs_1[1] = ((long) local6); + callArgs_1[0] = ((long) local10); + long[] callResult_1 = instance.getMachine().call(1889, callArgs_1); + local7 = ((int) callResult_1[0]); + if (local7 != 0) { + break label_7; + } + } + if (local8 != 0) { + break label_6; + } + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local7, -1) != 0) { + break label_2; + } + } + local3 = (local3 + 4); + } + local3 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) arg1); + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) (arg0 + 48)); + callArgs_2[0] = ((long) (local2 + 8)); + instance.getMachine().call(54, callArgs_2); + local3 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local6); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 31505); + callArgs_3[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + long[] callResult_3 = instance.getMachine().call(1847, callArgs_3); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_44(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_44(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_45(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_45(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_45(memory, instance); + return null; + } + + public static void func_46(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_46(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_46(memory, instance); + return null; + } + + public static void func_47(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(79, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local3); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local2 + 16)); + callArgs_1[2] = ((long) 30005); + callArgs_1[1] = ((long) 100); + callArgs_1[0] = ((long) (local2 + 32)); + long[] callResult_1 = instance.getMachine().call(1865, callArgs_1); + label_1: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local4 = memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (local2 + 32)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 31499); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 136, (byte) (arg1)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 17519); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 136)); + callArgs_3[0] = ((long) local3); + instance.getMachine().call(224, callArgs_3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 96, (int) 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 100, (int) arg1); + local3 = ((int) memory.read((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 19) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 19) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 19) + 0) & 0xFF); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) ((local2 + 136) + 4) < 0 ? ((local2 + 136) + 4) : ((local2 + 136) + 4) + 0, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 136, (int) 0); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) 0); + callArgs_4[3] = ((long) 30169); + callArgs_4[2] = ((long) (local3 != 0 ? 1 : 5)); + callArgs_4[1] = ((long) (local2 + 136)); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(224, callArgs_4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 92, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 104, (int) memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + instance.global(0).setValue(((long) (local2 + 144))); + return; + } + + public static long[] call_47(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_47(arg0, arg1, memory, instance); + return null; + } + + public static int func_48(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 19) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local4 = (arg2 + arg1); + local5 = (local5 - local4); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(167, callArgs_0); + local6 = ((int) callResult_0[0]); + arg2 = (local6 - arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_2; + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local5); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) (local6 + arg1)); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(225, callArgs_1); + } + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) arg3); + callArgs_2[2] = ((long) local5); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + long[] callResult_2 = instance.getMachine().call(171, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(220, callArgs_3); + return arg2; + } + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) arg3); + callArgs_4[2] = ((long) ((local5 - arg1) + -5)); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) local4); + long[] callResult_4 = instance.getMachine().call(168, callArgs_4); + return 0; + } + + public static long[] call_48(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_48(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_49(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 40); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) local4); + instance.getMachine().call(37, callArgs_0); + local4 = (arg1 + 34); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 8321); + callArgs_1[1] = ((long) (((((int) memory.read((int) (arg1 + 33) < 0 ? (arg1 + 33) : (arg1 + 33) + 0) & 0xFF) << 1) | ((int) memory.read((int) (arg1 + 32) < 0 ? (arg1 + 32) : (arg1 + 32) + 0) & 0xFF)) | (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) << 2))); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_1); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 16); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_2; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 13614); + callArgs_2[1] = local3; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(174, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 32) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 2558); + callArgs_3[1] = memory.readLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(174, callArgs_3); + break label_1; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 13614); + callArgs_4[1] = ((long) (int) local3); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(169, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 32) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 2558); + callArgs_5[1] = ((long) memory.readInt((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(169, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_49(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_49(arg0, arg1, memory, instance); + return null; + } + + public static void func_50(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + int local5 = 0; + local2 = (arg1 + 34); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 40); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 8321); + callArgs_0[1] = ((long) ((((((int) memory.read((int) (arg1 + 33) < 0 ? (arg1 + 33) : (arg1 + 33) + 0) & 0xFF) << 1) | ((int) memory.read((int) (arg1 + 32) < 0 ? (arg1 + 32) : (arg1 + 32) + 0) & 0xFF)) | (((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF) << 2)) | (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(65536, local3) << 3))); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_0); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 16); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF)) != 0) { + break label_2; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 13614); + callArgs_1[1] = local4; + callArgs_1[0] = ((long) local5); + instance.getMachine().call(174, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 32) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 2558); + callArgs_2[1] = memory.readLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(174, callArgs_2); + break label_1; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 13614); + callArgs_3[1] = ((long) (int) local4); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(169, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 32) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2558); + callArgs_4[1] = ((long) memory.readInt((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0)); + callArgs_4[0] = ((long) local5); + instance.getMachine().call(169, callArgs_4); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(65536, local3) != 0) { + break label_3; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + arg0 = 0; + label_4: { + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 2) != 0) { + break label_4; + } + arg0 = 0; + label_5: while (true) { + arg0 = (arg0 + 1); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 3); + arg1 = (arg1 >>> 1); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + arg0 = (arg0 & 255); + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 15143); + callArgs_5[1] = ((long) arg0); + callArgs_5[0] = ((long) local2); + instance.getMachine().call(169, callArgs_5); + } + return; + } + + public static long[] call_50(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_50(arg0, arg1, memory, instance); + return null; + } + + public static void func_51(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[9]; + long[] lL = new long[1]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = arg2; + iL[3] = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) iL[3])); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + int _d1 = func_51__h1(iL, lL, memory, instance); + if (_d1 == 1) + break label_2; + if (_d1 == 2) + break label_9; + if (_d1 == 3) + break label_8; + if (_d1 == 4) + break label_7; + if (_d1 == 5) + break label_6; + if (_d1 == 6) + break label_5; + if (_d1 == 7) + break label_4; + if (_d1 == 8) + break label_10; + if (_d1 == 9) + break label_3; + if (_d1 == 10) + break label_1; + } + long[] callArgs_165 = new long[2]; + callArgs_165[1] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)); + callArgs_165[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_165); + break label_1; + } + long[] callArgs_166 = new long[2]; + callArgs_166[1] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)); + callArgs_166[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_166); + break label_1; + } + long[] callArgs_167 = new long[2]; + callArgs_167[1] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)); + callArgs_167[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_167); + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (byte) (int) (memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 40))); + long[] callArgs_168 = new long[5]; + callArgs_168[4] = ((long) 0); + callArgs_168[3] = ((long) 13495); + callArgs_168[2] = ((long) 1); + callArgs_168[1] = ((long) (iL[3] + 16)); + callArgs_168[0] = ((long) iL[0]); + instance.getMachine().call(224, callArgs_168); + break label_1; + } + long[] callArgs_169 = new long[2]; + callArgs_169[1] = ((long) iL[2]); + callArgs_169[0] = ((long) iL[0]); + instance.getMachine().call(67, callArgs_169); + break label_1; + } + long[] callArgs_170 = new long[2]; + callArgs_170[1] = ((long) iL[2]); + callArgs_170[0] = ((long) iL[0]); + instance.getMachine().call(68, callArgs_170); + break label_1; + } + long[] callArgs_171 = new long[2]; + callArgs_171[1] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)); + callArgs_171[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_171); + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0, (long) memory.readLong((int) (iL[2] + 48) < 0 ? (iL[2] + 48) : (iL[2] + 48) + 0)); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 40)); + long[] callArgs_172 = new long[5]; + callArgs_172[4] = ((long) 0); + callArgs_172[3] = ((long) 13531); + callArgs_172[2] = ((long) 16); + callArgs_172[1] = ((long) (iL[3] + 16)); + callArgs_172[0] = ((long) iL[0]); + instance.getMachine().call(224, callArgs_172); + break label_1; + } + long[] callArgs_173 = new long[2]; + callArgs_173[1] = ((long) iL[2]); + callArgs_173[0] = ((long) iL[0]); + instance.getMachine().call(69, callArgs_173); + break label_1; + } + long[] callArgs_174 = new long[2]; + callArgs_174[1] = ((long) iL[2]); + callArgs_174[0] = ((long) iL[0]); + instance.getMachine().call(70, callArgs_174); + break label_1; + } + long[] callArgs_175 = new long[2]; + callArgs_175[1] = ((long) 0); + callArgs_175[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_175); + break label_1; + } + label_96: { + label_97: { + label_98: { + long[] callArgs_176 = new long[2]; + callArgs_176[1] = ((long) (iL[2] + 36)); + callArgs_176[0] = ((long) (iL[0] + 136)); + long[] callResult_176 = instance.getMachine().call(71, callArgs_176); + iL[1] = ((int) callResult_176[0]); + iL[4] = memory.readInt((int) (iL[1] + 4) < 0 ? (iL[1] + 4) : (iL[1] + 4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0)) != 0) { + break label_98; + } + iL[5] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 160); + break label_97; + } + iL[5] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 160); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[5], memory.readInt((int) (iL[4] + -16) < 0 ? (iL[4] + -16) : (iL[4] + -16) + 0)) != 0) { + break label_96; + } + } + long[] callArgs_177 = new long[2]; + callArgs_177[1] = ((long) iL[5]); + callArgs_177[0] = ((long) iL[1]); + instance.getMachine().call(72, callArgs_177); + iL[4] = memory.readInt((int) (iL[1] + 4) < 0 ? (iL[1] + 4) : (iL[1] + 4) + 0); + } + long[] callArgs_178 = new long[4]; + callArgs_178[3] = ((long) memory.readInt((int) (iL[2] + 48) < 0 ? (iL[2] + 48) : (iL[2] + 48) + 0)); + callArgs_178[2] = ((long) memory.readInt((int) (iL[2] + 44) < 0 ? (iL[2] + 44) : (iL[2] + 44) + 0)); + callArgs_178[1] = ((long) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4) - memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 156))); + callArgs_178[0] = ((long) (iL[4] + -12)); + instance.getMachine().call(73, callArgs_178); + } + instance.global(0).setValue(((long) (iL[3] + 32))); + return; + } + + public static long[] call_51(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_51(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_52(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local2 + 16)); + callArgs_0[2] = ((long) 30864); + callArgs_0[1] = ((long) 100); + callArgs_0[0] = ((long) (local2 + 32)); + long[] callResult_0 = instance.getMachine().call(1865, callArgs_0); + label_1: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local4 = memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (local2 + 32)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) 31499); + callArgs_1[0] = ((long) local4); + instance.getMachine().call(223, callArgs_1); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 136, (byte) (0)); + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) 0); + callArgs_2[3] = ((long) 17519); + callArgs_2[2] = ((long) 1); + callArgs_2[1] = ((long) (local2 + 136)); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(224, callArgs_2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 96, (long) 1L); + local4 = ((int) memory.read((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 19) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 19) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 19) + 0) & 0xFF); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) ((local2 + 136) + 4) < 0 ? ((local2 + 136) + 4) : ((local2 + 136) + 4) + 0, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 136, (int) 0); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 30169); + callArgs_3[2] = ((long) (local4 != 0 ? 1 : 5)); + callArgs_3[1] = ((long) (local2 + 136)); + callArgs_3[0] = ((long) local3); + instance.getMachine().call(224, callArgs_3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 92, (int) local5); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 104, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 4)); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + arg0 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 14225); + callArgs_5[1] = ((long) arg0); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(169, callArgs_5); + long[] callArgs_6 = new long[5]; + callArgs_6[4] = ((long) 1); + callArgs_6[3] = ((long) 16848); + callArgs_6[2] = ((long) arg0); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) local3); + instance.getMachine().call(224, callArgs_6); + instance.global(0).setValue(((long) (local2 + 144))); + return; + } + + public static long[] call_52(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_52(arg0, arg1, memory, instance); + return null; + } + + public static void func_53(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg1); + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 88), memory.readInt((int) local4 < 0 ? local4 : local4 + 4)) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100)); + long[] callResult_0 = instance.getMachine().call(79, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 88); + label_3: { + label_4: { + local6 = (arg0 + 76); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local8 = memory.readInt((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, local8) != 0) { + break label_4; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 8, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 4, (int) local5); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local4); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) (local7 + 20)); + break label_3; + } + label_5: { + label_6: { + label_7: { + label_8: { + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 72); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local7 - local9), 20); + local6 = (local10 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 214748365) != 0) { + break label_8; + } + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local8 - local9), 20); + local11 = (local8 << 1); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 107374182) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local11, local6) != 0 ? local11 : local6) : 214748364); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 214748365) != 0) { + break label_7; + } + local6 = (local6 * 20); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local8 = ((int) callResult_1[0]); + local10 = (local8 + (local10 * 20)); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 8, (long) 0L); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 4, (int) local5); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) local4); + memory.writeI32((int) (local10 + 16) < 0 ? (local10 + 16) : (local10 + 16) + 0, (int) 0); + local11 = (local8 + local6); + local12 = (local10 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, local7) != 0) { + break label_6; + } + local4 = 0; + label_9: while (true) { + local5 = (local10 + local4); + local6 = (local7 + local4); + memory.writeLong((int) (local5 + -20) < 0 ? (local5 + -20) : (local5 + -20) + 0, (long) memory.readLong((int) (local6 + -20) < 0 ? (local6 + -20) : (local6 + -20) + 0)); + local8 = (local6 + -12); + memory.writeLong((int) (local5 + -12) < 0 ? (local5 + -12) : (local5 + -12) + 0, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + _snap_0 = local5; + local5 = (local6 + -4); + memory.writeI32((int) (_snap_0 + -4) < 0 ? (_snap_0 + -4) : (_snap_0 + -4) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + local4 = (local4 + -20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, (local7 + local4)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + memory.writeI32((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0, (int) local11); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 72); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) (local10 + local4)); + local5 = (arg0 + 76); + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local4) != 0) { + break label_5; + } + local4 = (local4 + -12); + label_10: while (true) { + label_11: { + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_11; + } + memory.writeI32((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (int) local5); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_2); + } + local5 = (local4 + -8); + local4 = (local4 + -20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break label_5; + } + } + instance.getMachine().call(76, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local10); + memory.writeI32((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0, (int) local11); + memory.writeI32((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0, (int) local12); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_3; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_5); + } + local4 = (memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0) + -20); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 84, (int) local4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 104))); + label_12: { + label_13: { + label_14: { + label_15: { + label_16: { + label_17: { + label_18: { + switch(arg1) { + case 0: + { + break label_15; + } + case 1: + { + break label_16; + } + case 2: + { + break label_16; + } + case 3: + { + break label_16; + } + case 4: + { + break label_16; + } + case 5: + { + break label_16; + } + case 6: + { + break label_13; + } + case 7: + { + break label_17; + } + case 8: + { + break label_16; + } + case 9: + { + break label_16; + } + case 10: + { + break label_16; + } + case 11: + { + break label_16; + } + case 12: + { + break label_16; + } + case 13: + { + break label_16; + } + case 14: + { + break label_16; + } + case 15: + { + break label_16; + } + case 16: + { + break label_16; + } + case 17: + { + break label_16; + } + case 18: + { + break label_16; + } + case 19: + { + break label_16; + } + case 20: + { + break label_18; + } + default: + { + break label_16; + } + } + } + local7 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0) - local7) >> 2), arg2) != 0) { + break label_14; + } + break label_12; + } + local7 = memory.readInt((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0) - local7) >> 2), arg2) != 0) { + break label_14; + } + break label_12; + } + local7 = memory.readInt((int) 0 < 0 ? 0 : 0 + 61628); + local4 = 27457; + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 26) != 0) { + break label_19; + } + local4 = memory.readInt((int) (62288 + (arg1 << 2)) < 0 ? (62288 + (arg1 << 2)) : (62288 + (arg1 << 2)) + 0); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local4); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local3); + callArgs_6[1] = ((long) 31608); + callArgs_6[0] = ((long) local7); + long[] callResult_6 = instance.getMachine().call(1847, callArgs_6); + break label_12; + } + local7 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(((memory.readInt((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0) - local7) >> 2), arg2) != 0) { + break label_12; + } + } + arg2 = memory.readInt((int) (local7 + (arg2 << 2)) < 0 ? (local7 + (arg2 << 2)) : (local7 + (arg2 << 2)) + 0); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, arg2) != 0) { + break label_12; + } + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) (local3 + 4)); + callArgs_7[2] = ((long) (local3 + 8)); + callArgs_7[1] = ((long) (local3 + 12)); + callArgs_7[0] = ((long) (local4 + 8)); + long[] callResult_7 = instance.getMachine().call(77, callArgs_7); + } + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_53(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_53(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_54(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (local4 != 0) { + break label_4; + } + local5 = (arg1 + 4); + local6 = local5; + break label_3; + } + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + arg2 = (int) (local7 >>> 32L); + local8 = (int) local7; + label_5: while (true) { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + local6 = local4; + local7 = memory.readLong((int) local6 < 0 ? local6 : local6 + 16); + local4 = (int) (local7 >>> 32L); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, arg2); + local5 = (local9 != 0 ? local4 : arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_11; + } + label_12: { + local10 = (int) local7; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local5); + callArgs_0[1] = ((long) local10); + callArgs_0[0] = ((long) local8); + long[] callResult_0 = instance.getMachine().call(1889, callArgs_0); + local11 = ((int) callResult_0[0]); + if (local11 != 0) { + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, local4) != 0) { + break label_10; + } + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local11, -1) != 0) { + break label_9; + } + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, local4) != 0) { + break label_8; + } + } + local5 = local6; + local4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break label_3; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) local8); + callArgs_1[0] = ((long) local10); + long[] callResult_1 = instance.getMachine().call(1889, callArgs_1); + local4 = ((int) callResult_1[0]); + if (local4 != 0) { + break label_7; + } + } + if (local9 != 0) { + break label_6; + } + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local4, -1) != 0) { + break label_2; + } + } + local4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + local5 = (local6 + 4); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 24); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) local6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 16, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg2); + local4 = arg2; + label_13: { + local6 = memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_13; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local6); + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + instance.getMachine().call(43, callArgs_3); + local4 = 1; + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) + 1)); + break label_1; + } + local4 = 0; + arg2 = local6; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 4, (byte) (local4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg2); + return; + } + + public static long[] call_54(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_54(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_55(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + label_2: while (true) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(51, callArgs_0); + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + return; + } + + public static long[] call_55(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_55(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_56(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 14)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 15)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7200); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_56(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_56(arg0, arg1, memory, instance); + return null; + } + + public static void func_57(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 14)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 15)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7200); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_57(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_57(arg0, arg1, memory, instance); + return null; + } + + public static void func_58(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 14)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 15)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7200); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_58(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_58(arg0, arg1, memory, instance); + return null; + } + + public static void func_59(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 14)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 15)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7200); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_59(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_59(arg0, arg1, memory, instance); + return null; + } + + public static void func_60(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 14)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 15)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7200); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_60(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_60(arg0, arg1, memory, instance); + return null; + } + + public static void func_61(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 14)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 15)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7200); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_61(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_61(arg0, arg1, memory, instance); + return null; + } + + public static void func_62(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 40), memory.readInt((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0)) != 0) { + break label_2; + } + local3 = memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0); + local4 = memory.readInt((int) (arg1 + 52) < 0 ? (arg1 + 52) : (arg1 + 52) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local3 - local4), 15) != 0) { + break label_2; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_3; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) -64L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) -64L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg1); + instance.getMachine().call(37, callArgs_0); + break label_1; + } + local5 = memory.readLong((int) local4 < 0 ? local4 : local4 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) local5); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local5); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 0); + callArgs_1[1] = ((long) (local2 + 8)); + callArgs_1[0] = ((long) arg1); + instance.getMachine().call(37, callArgs_1); + break label_1; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)) != 0) { + break label_5; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 4)); + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(125, callArgs_2); + arg1 = ((int) callResult_2[0]); + break label_4; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (arg1 + 40)); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = instance.getMachine().call(134, callArgs_3); + arg1 = ((int) callResult_3[0]); + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 20) & 0xFF)) != 0) { + break label_6; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg1); + callArgs_4[1] = ((long) 6); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(53, callArgs_4); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 1553); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(176, callArgs_5); + break label_1; + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 1553); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(173, callArgs_6); + } + instance.global(0).setValue(((long) (local2 + 32))); + return; + } + + public static long[] call_62(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_62(arg0, arg1, memory, instance); + return null; + } + + public static void func_63(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 20) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) arg3); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(53, callArgs_0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(170, callArgs_1); + return; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg2); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_2); + return; + } + + public static long[] call_63(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_63(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_64(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + label_1: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 20) & 0xFF)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 10) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 20); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(53, callArgs_0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(176, callArgs_1); + return; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg2); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(173, callArgs_2); + return; + } + + public static long[] call_64(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_64(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_65(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 14)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 15)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7265); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_65(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_65(arg0, arg1, memory, instance); + return null; + } + + public static void func_66(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 14)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 15)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7240); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_66(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_66(arg0, arg1, memory, instance); + return null; + } + + public static void func_67(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 13, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 13)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 14)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7265); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (int) (memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 96))); + long[] callArgs_7 = new long[5]; + callArgs_7[4] = ((long) 0); + callArgs_7[3] = ((long) 13495); + callArgs_7[2] = ((long) 1); + callArgs_7[1] = ((long) (local2 + 15)); + callArgs_7[0] = ((long) local3); + instance.getMachine().call(224, callArgs_7); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_67(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_67(arg0, arg1, memory, instance); + return null; + } + + public static void func_68(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 13, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 13)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 14)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7240); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (int) (memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 96))); + long[] callArgs_7 = new long[5]; + callArgs_7[4] = ((long) 0); + callArgs_7[3] = ((long) 13495); + callArgs_7[2] = ((long) 1); + callArgs_7[1] = ((long) (local2 + 15)); + callArgs_7[0] = ((long) local3); + instance.getMachine().call(224, callArgs_7); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_68(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_68(arg0, arg1, memory, instance); + return null; + } + + public static void func_69(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 14)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 15)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7265); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_69(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_69(arg0, arg1, memory, instance); + return null; + } + + public static void func_70(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(36, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + local3 = (int) callResult_1[0]; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 36)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + long[] callResult_2 = instance.getMachine().call(124, callArgs_2); + local4 = ((int) callResult_2[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local6 = 64; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_3; + } + local6 = 0; + label_4: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = (local6 | 64); + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 14, (byte) (local6)); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 6882); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local2 + 14)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(224, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2416); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(169, callArgs_4); + break label_1; + } + local6 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2) != 0) { + break label_5; + } + local6 = 0; + label_6: while (true) { + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3); + local3 = (local3 >>> 1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (local6)); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) 6882); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 15)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(224, callArgs_5); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 7265); + callArgs_6[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(174, callArgs_6); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_70(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_70(arg0, arg1, memory, instance); + return null; + } + + public static int func_71(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + long local2 = 0L; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + int local10 = 0; + float local11 = 0.0f; + float local12 = 0.0f; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + local3 = (int) local2; + label_1: { + label_2: { + local4 = (int) (local2 >>> 32L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 4) != 0) { + break label_2; + } + local5 = local4; + arg1 = local3; + local6 = local4; + break label_1; + } + label_3: { + label_4: { + local6 = (local4 + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local6 & 4)) != 0) { + break label_4; + } + local7 = local4; + arg1 = local3; + local5 = local4; + break label_3; + } + arg1 = (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) * 1540483477); + local5 = ((((arg1 >>> 24) ^ arg1) * 1540483477) ^ (local4 * 1540483477)); + arg1 = (local3 + 4); + local7 = local6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 4) != 0) { + break label_1; + } + local6 = local7; + label_5: while (true) { + local7 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) * 1540483477); + _snap_0 = local7; + local7 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) * 1540483477); + local5 = ((((_snap_0 >>> 24) ^ _snap_0) * 1540483477) ^ (((((local7 >>> 24) ^ local7) * 1540483477) ^ (local5 * 1540483477)) * 1540483477)); + arg1 = (arg1 + 8); + local6 = (local6 + -8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + label_6: { + label_7: { + label_8: { + label_9: { + switch((local6 + -1)) { + case 0: + { + break label_7; + } + case 1: + { + break label_8; + } + case 2: + { + break label_9; + } + default: + { + break label_6; + } + } + } + local5 = ((((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 2) & 0xFF) << 16) ^ local5); + } + local5 = ((((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 1) & 0xFF) << 8) ^ local5); + } + local5 = ((local5 ^ ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)) * 1540483477); + } + arg1 = (((local5 >>> 13) ^ local5) * 1540483477); + local8 = ((arg1 >>> 15) ^ arg1); + label_10: { + label_11: { + label_12: { + label_13: { + arg1 = memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0); + if (arg1 != 0) { + break label_13; + } + break label_12; + } + label_14: { + label_15: { + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, 1) != 0) { + break label_15; + } + local6 = (local8 & (arg1 + -1)); + break label_14; + } + local6 = local8; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, arg1) != 0) { + break label_14; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local8, arg1); + } + local5 = memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_12; + } + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_12; + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 2) != 0) { + break label_16; + } + label_17: while (true) { + label_18: { + local7 = memory.readInt((int) (local5 + 4) < 0 ? (local5 + 4) : (local5 + 4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local7) != 0) { + break label_18; + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, arg1) != 0) { + break label_19; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local7, arg1); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local7) != 0) { + break label_12; + } + } + label_20: { + local9 = memory.readLong((int) local5 < 0 ? local5 : local5 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, (int) (local9 >>> 32L)) != 0) { + break label_20; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_11; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local4); + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (int) local9); + long[] callResult_0 = instance.getMachine().call(1889, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_0[0])) != 0) { + break label_11; + } + } + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_17; + } + break label_12; + } + } + local10 = (arg1 + -1); + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_21; + } + label_22: while (true) { + label_23: { + local7 = memory.readInt((int) (local5 + 4) < 0 ? (local5 + 4) : (local5 + 4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local7) != 0) { + break label_23; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, (local7 & local10)) != 0) { + break label_12; + } + } + label_24: { + local9 = memory.readLong((int) local5 < 0 ? local5 : local5 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, (int) (local9 >>> 32L)) != 0) { + break label_24; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) (int) local9); + long[] callResult_1 = instance.getMachine().call(1889, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_1[0])) != 0) { + break label_11; + } + } + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_22; + } + break label_12; + } + } + label_25: while (true) { + label_26: { + local7 = memory.readInt((int) (local5 + 4) < 0 ? (local5 + 4) : (local5 + 4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local7) != 0) { + break label_26; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, (local7 & local10)) != 0) { + break label_12; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(memory.readLong((int) local5 < 0 ? local5 : local5 + 8), 4294967296L) != 0) { + break label_11; + } + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_25; + } + break; + } + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 28); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local5 = ((int) callResult_2[0]); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) 0L); + memory.writeI32((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (int) 0); + local10 = (arg0 + 8); + local11 = memory.readFloat((int) arg0 < 0 ? arg0 : arg0 + 16); + local12 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 1)); + label_27: { + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_28; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(com.dylibso.chicory.runtime.OpcodeImpl.F32_LT((local11 * com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U(arg1)), local12)) != 0) { + break label_27; + } + } + local6 = ((arg1 << 1) | (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (arg1 & (arg1 + -1))))); + label_29: { + label_30: { + local12 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CEIL((local12 / local11)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.F32_LT(local12, 4.2949673E9f) & com.dylibso.chicory.runtime.OpcodeImpl.F32_GE(local12, 0.0f))) != 0) { + break label_30; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_TRUNC_F32_U(local12); + break label_29; + } + local7 = 0; + } + local4 = 2; + label_31: { + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local7) != 0 ? local6 : local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6) != 0) { + break label_31; + } + label_32: { + if ((local6 & (local6 + -1)) != 0) { + break label_32; + } + local4 = local6; + break label_31; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(1572, callArgs_3); + local4 = ((int) callResult_3[0]); + arg1 = memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0); + } + label_33: { + label_34: { + label_35: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, arg1) != 0) { + break label_35; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, arg1) != 0) { + break label_33; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 3); + label_36: { + label_37: { + local12 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CEIL((com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)) / memory.readFloat((int) arg0 < 0 ? arg0 : arg0 + 16))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.F32_LT(local12, 4.2949673E9f) & com.dylibso.chicory.runtime.OpcodeImpl.F32_GE(local12, 0.0f))) != 0) { + break label_37; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_TRUNC_F32_U(local12); + break label_36; + } + local6 = 0; + } + label_38: { + label_39: { + if (local7 != 0) { + break label_39; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(arg1), 1) != 0) { + break label_39; + } + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 2) != 0 ? local6 : (1 << (32 - com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ((local6 + -1))))); + break label_38; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1572, callArgs_4); + local6 = ((int) callResult_4[0]); + } + label_40: { + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, local6) != 0 ? local4 : local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, arg1) != 0) { + break label_40; + } + arg1 = memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0); + break label_33; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_34; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 1073741824) != 0) { + break label_10; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) (local4 << 2)); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + local6 = ((int) callResult_5[0]); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + label_41: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_41; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_6); + } + memory.writeI32((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0, (int) local4); + local6 = (local4 & 3); + local7 = 0; + label_42: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((local4 + -1), 3) != 0) { + break label_42; + } + local3 = (local4 & -4); + arg1 = 8; + local7 = 0; + label_43: while (true) { + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + -8) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + -8) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + -8) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + -4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + -4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + -4) + 0, (int) 0); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 4) + 0, (int) 0); + arg1 = (arg1 + 16); + local7 = (local7 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_43; + } + break; + } + } + label_44: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_44; + } + arg1 = (local7 << 2); + label_45: while (true) { + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0, (int) 0); + arg1 = (arg1 + 4); + local6 = (local6 + -1); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_45; + } + break; + } + } + label_46: { + arg1 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + if (arg1 != 0) { + break label_46; + } + arg1 = local4; + break label_33; + } + local3 = memory.readInt((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0); + label_47: { + label_48: { + local13 = (local4 + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local4 & local13)) != 0) { + break label_48; + } + label_49: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0) { + break label_49; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local3, local4); + } + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) + 0, (int) local10); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (local7 != 0) { + break label_47; + } + arg1 = local4; + break label_33; + } + local3 = (local3 & local13); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) + 0, (int) local10); + label_50: { + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (local6 != 0) { + break label_50; + } + arg1 = local4; + break label_33; + } + label_51: while (true) { + label_52: { + label_53: { + local7 = (memory.readInt((int) (local6 + 4) < 0 ? (local6 + 4) : (local6 + 4) + 0) & local13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local7) != 0) { + break label_53; + } + arg1 = local6; + break label_52; + } + label_54: { + local14 = (local7 << 2); + local15 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) local15 < 0 ? local15 : local15 + 0)) != 0) { + break label_54; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) memory.readInt((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) + 0) + 0)); + memory.writeI32((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local14) + 0) + 0, (int) local6); + break label_52; + } + memory.writeI32((int) local15 < 0 ? local15 : local15 + 0, (int) arg1); + arg1 = local6; + local3 = local7; + } + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_51; + } + break; + } + arg1 = local4; + break label_33; + } + label_55: while (true) { + label_56: { + local6 = memory.readInt((int) (local7 + 4) < 0 ? (local7 + 4) : (local7 + 4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local4) != 0) { + break label_56; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local6, local4); + } + label_57: { + label_58: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local6) != 0) { + break label_58; + } + arg1 = local7; + break label_57; + } + label_59: { + local13 = (local6 << 2); + local14 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13); + if (memory.readInt((int) local14 < 0 ? local14 : local14 + 0) != 0) { + break label_59; + } + memory.writeI32((int) local14 < 0 ? local14 : local14 + 0, (int) arg1); + arg1 = local7; + local3 = local6; + break label_57; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) memory.readInt((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) + 0) + 0)); + memory.writeI32((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local13) + 0) + 0, (int) local7); + } + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_55; + } + break; + } + arg1 = local4; + break label_33; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + arg1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 0); + label_60: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_60; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_7); + } + memory.writeI32((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0, (int) 0); + } + label_61: { + local6 = (arg1 + -1); + if ((arg1 & local6) != 0) { + break label_61; + } + local6 = (local6 & local8); + break label_27; + } + label_62: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, arg1) != 0) { + break label_62; + } + local6 = local8; + break label_27; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local8, arg1); + } + label_63: { + label_64: { + label_65: { + local7 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)); + local6 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + if (local6 != 0) { + break label_65; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local10 < 0 ? local10 : local10 + 0)); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) local5); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local10); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_63; + } + local6 = memory.readInt((int) (local6 + 4) < 0 ? (local6 + 4) : (local6 + 4) + 0); + label_66: { + label_67: { + local7 = (arg1 + -1); + if ((arg1 & local7) != 0) { + break label_67; + } + local6 = (local6 & local7); + break label_66; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, arg1) != 0) { + break label_66; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local6, arg1); + } + local6 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)); + break label_64; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local5); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 1)); + } + return (local5 + 16); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_71(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_71(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_72(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + local2 = (arg0 + 4); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + local4 = memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local4) != 0) { + break label_1; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0, (int) 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (local3 + 16)); + return; + } + label_2: { + label_3: { + label_4: { + label_5: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local6 = ((local3 - local5) >> 4); + local2 = (local6 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 268435456) != 0) { + break label_5; + } + local4 = (local4 - local5); + local7 = (local4 >>> 3); + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 2147483632) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, local2) != 0 ? local7 : local2) : 268435455); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 268435456) != 0) { + break label_4; + } + local2 = (local2 << 4); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local2); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local6 = (local4 + (local6 << 4)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 4, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg1); + memory.writeI32((int) (local6 + 12) < 0 ? (local6 + 12) : (local6 + 12) + 0, (int) 0); + local7 = (local4 + local2); + local8 = (local6 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local3) != 0) { + break label_3; + } + arg1 = 0; + label_6: while (true) { + local4 = (local6 + arg1); + local2 = (local3 + arg1); + memory.writeLong((int) (local4 + -16) < 0 ? (local4 + -16) : (local4 + -16) + 0, (long) memory.readLong((int) (local2 + -16) < 0 ? (local2 + -16) : (local2 + -16) + 0)); + memory.writeI32((int) (local4 + -8) < 0 ? (local4 + -8) : (local4 + -8) + 0, (int) memory.readInt((int) (local2 + -8) < 0 ? (local2 + -8) : (local2 + -8) + 0)); + _snap_0 = local4; + local4 = (local2 + -4); + memory.writeI32((int) (_snap_0 + -4) < 0 ? (_snap_0 + -4) : (_snap_0 + -4) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + memory.writeLong((int) (local2 + -12) < 0 ? (local2 + -12) : (local2 + -12) + 0, (long) 0L); + arg1 = (arg1 + -16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, (local3 + arg1)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) local7); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local6 + arg1)); + local2 = (arg0 + 4); + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg1) != 0) { + break label_2; + } + label_7: while (true) { + label_8: { + local6 = (arg1 + -16); + local5 = (local6 + 4); + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_8; + } + local2 = local4; + label_9: { + arg0 = (arg1 + -8); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, arg1) != 0) { + break label_9; + } + arg1 = (arg1 + -12); + label_10: while (true) { + label_11: { + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_11; + } + memory.writeI32((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0, (int) local2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + } + local2 = (arg1 + -4); + arg1 = (arg1 + -16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + local2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local4); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + } + arg1 = local6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break label_2; + } + } + instance.getMachine().call(74, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) local7); + memory.writeI32((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0, (int) local8); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_12; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_5); + } + return; + } + + public static long[] call_72(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_72(arg0, arg1, memory, instance); + return null; + } + + public static void func_73(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + local4 = memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0); + local5 = memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_6; + } + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, arg3) != 0) { + break label_8; + } + arg2 = 0; + local6 = 0; + break label_7; + } + arg3 = (arg3 - arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg3, -1) != 0) { + break label_5; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg3); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local6 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg3); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1890, callArgs_1); + arg2 = (((int) callResult_1[0]) + arg3); + } + memory.writeI32((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local6); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) arg2); + memory.writeI32((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0, (int) (local4 + 16)); + return; + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local8 = ((local4 - local7) >> 4); + local9 = (local8 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 268435456) != 0) { + break label_4; + } + local10 = 0; + local6 = 0; + label_9: { + local5 = (local5 - local7); + local11 = (local5 >>> 3); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483632) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local11, local9) != 0 ? local11 : local9) : 268435455); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 268435456) != 0) { + break label_3; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local5 << 4)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local6 = ((int) callResult_2[0]); + } + local9 = 0; + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg3) != 0) { + break label_10; + } + arg3 = (arg3 - arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg3, -1) != 0) { + break label_5; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg3); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local9 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg3); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) local9); + long[] callResult_4 = instance.getMachine().call(1890, callArgs_4); + local10 = (((int) callResult_4[0]) + arg3); + } + local5 = (local6 + (local5 << 4)); + local6 = (local6 + (local8 << 4)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local9); + memory.writeI32((int) (local6 + 12) < 0 ? (local6 + 12) : (local6 + 12) + 0, (int) local10); + memory.writeI32((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (int) local10); + local10 = (local6 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local4) != 0) { + break label_2; + } + arg2 = 0; + label_11: while (true) { + arg1 = (local6 + arg2); + arg3 = (local4 + arg2); + memory.writeLong((int) (arg1 + -16) < 0 ? (arg1 + -16) : (arg1 + -16) + 0, (long) memory.readLong((int) (arg3 + -16) < 0 ? (arg3 + -16) : (arg3 + -16) + 0)); + memory.writeI32((int) (arg1 + -8) < 0 ? (arg1 + -8) : (arg1 + -8) + 0, (int) memory.readInt((int) (arg3 + -8) < 0 ? (arg3 + -8) : (arg3 + -8) + 0)); + _snap_0 = arg1; + arg1 = (arg3 + -4); + memory.writeI32((int) (_snap_0 + -4) < 0 ? (_snap_0 + -4) : (_snap_0 + -4) + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + memory.writeLong((int) (arg3 + -12) < 0 ? (arg3 + -12) : (arg3 + -12) + 0, (long) 0L); + arg2 = (arg2 + -16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, (local4 + arg2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) local5); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local6 + arg2)); + arg3 = (arg0 + 4); + arg2 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) local10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, arg2) != 0) { + break label_1; + } + arg2 = (arg2 + -12); + label_12: while (true) { + label_13: { + arg3 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_13; + } + memory.writeI32((int) (arg2 + 4) < 0 ? (arg2 + 4) : (arg2 + 4) + 0, (int) arg3); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg3); + instance.getMachine().call(1777, callArgs_5); + } + arg3 = (arg2 + -4); + arg2 = (arg2 + -16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, arg3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(75, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) local5); + memory.writeI32((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0, (int) local10); + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_14; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_9); + } + return; + } + + public static long[] call_73(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_73(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_74(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_74(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_74(memory, instance); + return null; + } + + public static void func_75(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_75(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_75(memory, instance); + return null; + } + + public static void func_76(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_76(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_76(memory, instance); + return null; + } + + public static int func_77(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_4; + } + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0)); + callArgs_0[2] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(81, callArgs_0); + arg1 = (((int) callResult_0[0]) + 16); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + break label_3; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local7 = ((local4 - local6) >> 4); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 268435456) != 0) { + break label_2; + } + local4 = 0; + label_5: { + local5 = (local5 - local6); + local6 = (local5 >>> 3); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483632) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local8) != 0 ? local6 : local8) : 268435455); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 268435456) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local5 << 4)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local4 = ((int) callResult_1[0]); + } + local5 = (local4 + (local5 << 4)); + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) 0); + callArgs_2[3] = ((long) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0)); + callArgs_2[2] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + callArgs_2[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_2[0] = ((long) (local4 + (local7 << 4))); + long[] callResult_2 = instance.getMachine().call(81, callArgs_2); + arg3 = ((int) callResult_2[0]); + arg1 = (arg3 + 16); + label_6: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, local4) != 0) { + break label_6; + } + label_7: while (true) { + arg3 = (arg3 + -16); + local4 = (local4 + -16); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + return (arg1 + -16); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_77(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_77(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_78(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, 14) != 0) { + break label_1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + return memory.readInt((int) ((arg0 << 2) + 39764) < 0 ? ((arg0 << 2) + 39764) : ((arg0 << 2) + 39764) + 0); + } + + public static long[] call_78(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_78(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_79(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, 14) != 0) { + break label_1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + return memory.readInt((int) ((arg0 << 2) + 39820) < 0 ? ((arg0 << 2) + 39820) : ((arg0 << 2) + 39820) + 0); + } + + public static long[] call_79(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_79(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_80(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return memory.readInt((int) ((arg0 << 2) + 62208) < 0 ? ((arg0 << 2) + 62208) : ((arg0 << 2) + 62208) + 0); + } + + public static long[] call_80(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_80(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_81(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg1); + return arg0; + } + + public static long[] call_81(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_81(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_82(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local2 = (((int) instance.global(0).getValue()) - 224); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_3; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 219, (byte) (local3)); + local5 = (local2 + 208); + break label_2; + } + local6 = ((local3 | 15) + 1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local5 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 216, (int) (local6 | -2147483648)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 208, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 212, (int) local3); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1891, callArgs_1); + memory.writeByte((int) (((int) callResult_1[0]) + local3) < 0 ? (((int) callResult_1[0]) + local3) : (((int) callResult_1[0]) + local3) + 0, (byte) (0)); + local3 = (int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 219); + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 208); + label_4: { + label_5: { + local7 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(4294967296L, (local7 & -4294967296L)) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(45, ((int) memory.read((int) (int) local7 < 0 ? (int) local7 : (int) local7 + 0) & 0xFF)) != 0) { + break label_5; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 12902); + callArgs_2[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61632)); + long[] callResult_2 = instance.getMachine().call(83, callArgs_2); + arg0 = ((int) callResult_2[0]); + break label_4; + } + label_6: { + arg0 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0 ? local5 : (local2 + 208)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 64)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1813, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(((int) callResult_3[0]), -1) != 0) { + break label_6; + } + local3 = memory.readInt((int) 0 < 0 ? 0 : 0 + 61628); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(0) != 0) { + break label_7; + } + instance.getMachine().call(16, new long[0]); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 658184)); + long[] callResult_5 = instance.getMachine().call(1823, callArgs_5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) ((int) callResult_5[0])); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local2); + callArgs_6[1] = ((long) 31600); + callArgs_6[0] = ((long) local3); + long[] callResult_6 = instance.getMachine().call(1847, callArgs_6); + arg0 = 1; + break label_4; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local2 + 89) < 0 ? (local2 + 89) : (local2 + 89) + 0) & 0xFF) & 64)) != 0) { + break label_8; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) arg0); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local2 + 48)); + callArgs_7[1] = ((long) 31380); + callArgs_7[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + long[] callResult_7 = instance.getMachine().call(1847, callArgs_7); + arg0 = 1; + break label_4; + } + label_9: { + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) 26668); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1846, callArgs_8); + local3 = ((int) callResult_8[0]); + if (local3 != 0) { + break label_9; + } + local3 = memory.readInt((int) 0 < 0 ? 0 : 0 + 61628); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(0) != 0) { + break label_10; + } + instance.getMachine().call(16, new long[0]); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 658184)); + long[] callResult_10 = instance.getMachine().call(1823, callArgs_10); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) ((int) callResult_10[0])); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg0); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local2 + 16)); + callArgs_11[1] = ((long) 31600); + callArgs_11[0] = ((long) local3); + long[] callResult_11 = instance.getMachine().call(1847, callArgs_11); + arg0 = 1; + break label_4; + } + label_11: { + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) 2); + callArgs_12[1] = ((long) 0); + callArgs_12[0] = ((long) local3); + long[] callResult_12 = instance.getMachine().call(1852, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(((int) callResult_12[0]), -1) != 0) { + break label_11; + } + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) arg1); + callArgs_13[1] = ((long) arg0); + callArgs_13[0] = ((long) local3); + long[] callResult_13 = instance.getMachine().call(83, callArgs_13); + arg0 = ((int) callResult_13[0]); + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local3); + long[] callResult_14 = instance.getMachine().call(1831, callArgs_14); + break label_4; + } + label_12: { + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local3); + long[] callResult_15 = instance.getMachine().call(1853, callArgs_15); + local5 = ((int) callResult_15[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local5, -1) != 0) { + break label_12; + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) 18888); + instance.getMachine().call(1862, callArgs_16); + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local3); + long[] callResult_17 = instance.getMachine().call(1831, callArgs_17); + arg0 = 1; + break label_4; + } + label_13: { + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) 0); + callArgs_18[1] = ((long) 0); + callArgs_18[0] = ((long) local3); + long[] callResult_18 = instance.getMachine().call(1852, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(((int) callResult_18[0]), -1) != 0) { + break label_13; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) 25980); + instance.getMachine().call(1862, callArgs_19); + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) local3); + long[] callResult_20 = instance.getMachine().call(1831, callArgs_20); + arg0 = 1; + break label_4; + } + label_14: { + label_15: { + label_16: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local5, local6) != 0) { + break label_16; + } + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) (local5 - local6)); + callArgs_21[0] = ((long) arg1); + instance.getMachine().call(84, callArgs_21); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + break label_15; + } + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local6) != 0) { + break label_17; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (local4 + local5)); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_14; + } + } + long[] callArgs_22 = new long[4]; + callArgs_22[3] = ((long) local3); + callArgs_22[2] = ((long) 1); + callArgs_22[1] = ((long) local5); + callArgs_22[0] = ((long) local4); + long[] callResult_22 = instance.getMachine().call(1851, callArgs_22); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_22[0])) != 0) { + break label_14; + } + arg1 = memory.readInt((int) 0 < 0 ? 0 : 0 + 61628); + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(0) != 0) { + break label_18; + } + instance.getMachine().call(16, new long[0]); + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 658184)); + long[] callResult_24 = instance.getMachine().call(1823, callArgs_24); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) ((int) callResult_24[0])); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) arg0); + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) (local2 + 32)); + callArgs_25[1] = ((long) 31675); + callArgs_25[0] = ((long) arg1); + long[] callResult_25 = instance.getMachine().call(1847, callArgs_25); + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) local3); + long[] callResult_26 = instance.getMachine().call(1831, callArgs_26); + arg0 = 1; + break label_4; + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) local3); + long[] callResult_27 = instance.getMachine().call(1831, callArgs_27); + arg0 = 0; + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 219), -1) != 0) { + break label_19; + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 208)); + instance.getMachine().call(1777, callArgs_28); + } + instance.global(0).setValue(((long) (local2 + 224))); + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_82(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_82(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_83(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 4112); + instance.global(0).setValue(((long) local3)); + label_1: { + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4)) != 0) { + break label_1; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) local4); + } + label_2: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg0); + callArgs_0[2] = ((long) 4096); + callArgs_0[1] = ((long) 1); + callArgs_0[0] = ((long) (local3 + 16)); + long[] callResult_0 = instance.getMachine().call(1851, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + label_3: while (true) { + label_4: { + label_5: { + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local6 = (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) - local5); + local7 = (local6 + local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local7) != 0) { + break label_5; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg2); + instance.getMachine().call(84, callArgs_1); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local6, local7) != 0) { + break label_4; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) (local5 + local7)); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) (local3 + 16)); + callArgs_2[0] = ((long) (local5 + local6)); + long[] callResult_2 = instance.getMachine().call(1890, callArgs_2); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg0); + callArgs_3[2] = ((long) 4096); + callArgs_3[1] = ((long) 1); + callArgs_3[0] = ((long) (local3 + 16)); + long[] callResult_3 = instance.getMachine().call(1851, callArgs_3); + local4 = ((int) callResult_3[0]); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + local4 = 0; + label_6: { + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1832, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_4[0])) != 0) { + break label_6; + } + local4 = memory.readInt((int) 0 < 0 ? 0 : 0 + 61628); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(0) != 0) { + break label_7; + } + instance.getMachine().call(16, new long[0]); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 658184)); + long[] callResult_6 = instance.getMachine().call(1823, callArgs_6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) ((int) callResult_6[0])); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local3); + callArgs_7[1] = ((long) 31566); + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(1847, callArgs_7); + local4 = 1; + } + instance.global(0).setValue(((long) (local3 + 4112))); + return local4; + } + + public static long[] call_83(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_83(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_84(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((local2 - local3), arg1) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + local3 = (((int) callResult_0[0]) + arg1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + return; + } + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = (local3 - local4); + local6 = (local5 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local6, -1) != 0) { + break label_3; + } + local7 = 0; + label_4: { + local2 = (local2 - local4); + local8 = (local2 << 1); + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6) : 2147483647); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_4; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + } + local6 = (local7 + local2); + local2 = (local7 + local5); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + local9 = ((int) callResult_2[0]); + local8 = (local9 + arg1); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_6; + } + local7 = local9; + break label_5; + } + local9 = ((local4 ^ -1) + local3); + label_7: { + arg1 = (local5 & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_7; + } + label_8: while (true) { + local2 = (local2 + -1); + local3 = (local3 + -1); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 0, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF))); + arg1 = (arg1 + -1); + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, 3) != 0) { + break label_9; + } + local2 = (local2 + -4); + label_10: while (true) { + memory.writeByte((int) (local2 + 3) < 0 ? (local2 + 3) : (local2 + 3) + 0, (byte) (((int) memory.read((int) (local3 + -1) < 0 ? (local3 + -1) : (local3 + -1) + 0) & 0xFF))); + memory.writeByte((int) (local2 + 2) < 0 ? (local2 + 2) : (local2 + 2) + 0, (byte) (((int) memory.read((int) (local3 + -2) < 0 ? (local3 + -2) : (local3 + -2) + 0) & 0xFF))); + memory.writeByte((int) (local2 + 1) < 0 ? (local2 + 1) : (local2 + 1) + 0, (byte) (((int) memory.read((int) (local3 + -3) < 0 ? (local3 + -3) : (local3 + -3) + 0) & 0xFF))); + local3 = (local3 + -4); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 0, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF))); + local2 = (local2 + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_11; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_84(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_84(arg0, arg1, memory, instance); + return null; + } + + public static void func_85(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return; + } + + public static long[] call_85(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_85(memory, instance); + return null; + } + + public static int func_86(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg1); + local3 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + label_2: { + label_3: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 26987); + long[] callResult_0 = instance.getMachine().call(1822, callArgs_0); + local3 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + long[] callResult_1 = instance.getMachine().call(1877, callArgs_1); + local3 = ((int) callResult_1[0]); + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(1834, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) ((int) callResult_2[0])); + long[] callResult_3 = instance.getMachine().call(1808, callArgs_3); + local3 = ((int) callResult_3[0]); + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local3); + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 4, (byte) (local3)); + return arg0; + } + + public static long[] call_86(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_86(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_87(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + long local16 = 0L; + local8 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local8)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) 0); + label_1: { + local9 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local10 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local10, local9) != 0) { + break label_1; + } + label_2: while (true) { + label_3: { + local11 = memory.readInt((int) arg5 < 0 ? arg5 : arg5 + 4); + arg1 = ((int) memory.read((int) arg5 < 0 ? arg5 : arg5 + 11) & 0xFF); + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1); + local13 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local12, 0); + local14 = (local13 != 0 ? local11 : arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local14) != 0) { + break label_3; + } + label_4: { + label_5: { + switch((arg6 + -1)) { + case 0: + { + break label_5; + } + case 1: + { + break label_4; + } + default: + { + break label_3; + } + } + } + arg6 = 0; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local14); + callArgs_0[1] = ((long) (local13 != 0 ? memory.readInt((int) arg5 < 0 ? arg5 : arg5 + 0) : arg5)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1652, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 32380); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1662, callArgs_1); + local11 = memory.readInt((int) arg5 < 0 ? arg5 : arg5 + 4); + arg1 = ((int) memory.read((int) arg5 < 0 ? arg5 : arg5 + 11) & 0xFF); + local12 = arg1; + } + local11 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local12), 0) != 0 ? local11 : arg1); + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local11) << 1); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 75, (byte) (arg1)); + label_6: { + label_7: { + label_8: { + label_9: { + if (local11 != 0) { + break label_9; + } + memory.writeByte((int) ((local8 + 64) | arg1) < 0 ? ((local8 + 64) | arg1) : ((local8 + 64) | arg1) + 0, (byte) (0)); + break label_8; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 32); + callArgs_2[0] = ((long) (local8 + 64)); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + memory.writeByte((int) ((local8 + 64) | arg1) < 0 ? ((local8 + 64) | arg1) : ((local8 + 64) | arg1) + 0, (byte) (0)); + arg1 = (int) (byte) memory.read((int) local8 < 0 ? local8 : local8 + 75); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_7; + } + } + memory.writeI32((int) ((local8 + 32) + 8) < 0 ? ((local8 + 32) + 8) : ((local8 + 32) + 8) + 0, (int) memory.readInt((int) ((local8 + 64) + 8) < 0 ? ((local8 + 64) + 8) : ((local8 + 64) + 8) + 0)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 32, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 64)); + local15 = 0; + break label_6; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 68)); + callArgs_3[1] = ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 64)); + callArgs_3[0] = ((long) (local8 + 32)); + instance.getMachine().call(1647, callArgs_3); + local15 = 1; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (((int) memory.read((int) arg4 < 0 ? arg4 : arg4 + 4) & 0xFF) != 0 ? 13056 : 38861)); + callArgs_4[0] = ((long) (local8 + 32)); + long[] callResult_4 = instance.getMachine().call(1662, callArgs_4); + local12 = (local9 + 4); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) (local9 + 8) < 0 ? (local9 + 8) : (local9 + 8) + 0)) != 0) { + break label_10; + } + local16 = memory.readLong((int) local12 < 0 ? local12 : local12 + 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (int) (local16 >>> 32L)); + callArgs_5[1] = ((long) (int) local16); + callArgs_5[0] = ((long) (local8 + 32)); + long[] callResult_5 = instance.getMachine().call(1652, callArgs_5); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 27556); + callArgs_6[0] = ((long) (local8 + 32)); + long[] callResult_6 = instance.getMachine().call(1662, callArgs_6); + } + label_11: { + label_12: { + if (arg2 != 0) { + break label_12; + } + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) (local9 + 12) < 0 ? (local9 + 12) : (local9 + 12) + 0)); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local8); + callArgs_7[1] = ((long) 31349); + callArgs_7[0] = ((long) (local8 + 48)); + instance.getMachine().call(39, callArgs_7); + local11 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 59) & 0xFF); + local13 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local11), 0); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (local13 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 52) : local11)); + callArgs_8[1] = ((long) (local13 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 48) : (local8 + 48))); + callArgs_8[0] = ((long) (local8 + 32)); + long[] callResult_8 = instance.getMachine().call(1652, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local8 < 0 ? local8 : local8 + 59), -1) != 0) { + break label_11; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 48)); + instance.getMachine().call(1777, callArgs_9); + break label_11; + } + local11 = memory.readInt((int) (local9 + 12) < 0 ? (local9 + 12) : (local9 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, local11) != 0) { + break label_11; + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 16, (int) local11); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) (local8 + 16)); + callArgs_10[1] = ((long) 31120); + callArgs_10[0] = ((long) (local8 + 48)); + instance.getMachine().call(39, callArgs_10); + local11 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 59) & 0xFF); + local13 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local11), 0); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local13 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 52) : local11)); + callArgs_11[1] = ((long) (local13 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 48) : (local8 + 48))); + callArgs_11[0] = ((long) (local8 + 32)); + long[] callResult_11 = instance.getMachine().call(1652, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local8 < 0 ? local8 : local8 + 59), -1) != 0) { + break label_11; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 48)); + instance.getMachine().call(1777, callArgs_12); + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) (((int) memory.read((int) arg4 < 0 ? arg4 : arg4 + 4) & 0xFF) != 0 ? 13061 : 38861)); + callArgs_13[0] = ((long) (local8 + 32)); + long[] callResult_13 = instance.getMachine().call(1662, callArgs_13); + local11 = 14377; + label_13: { + label_14: { + label_15: { + switch(memory.readInt((int) local9 < 0 ? local9 : local9 + 0)) { + case 0: + { + break label_13; + } + case 1: + { + break label_14; + } + default: + { + break label_15; + } + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local11 = 11424; + } + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) local11); + callArgs_15[0] = ((long) (local8 + 32)); + long[] callResult_15 = instance.getMachine().call(1662, callArgs_15); + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) 31354); + callArgs_16[0] = ((long) (local8 + 32)); + long[] callResult_16 = instance.getMachine().call(1662, callArgs_16); + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) (((int) memory.read((int) arg4 < 0 ? arg4 : arg4 + 4) & 0xFF) != 0 ? 13067 : 38861)); + callArgs_17[0] = ((long) (local8 + 32)); + long[] callResult_17 = instance.getMachine().call(1662, callArgs_17); + local11 = (local9 + 24); + local13 = ((int) memory.read((int) local9 < 0 ? local9 : local9 + 35) & 0xFF); + local14 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local13), 0); + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) (local14 != 0 ? memory.readInt((int) (local9 + 28) < 0 ? (local9 + 28) : (local9 + 28) + 0) : local13)); + callArgs_18[1] = ((long) (local14 != 0 ? memory.readInt((int) local11 < 0 ? local11 : local11 + 0) : local11)); + callArgs_18[0] = ((long) (local8 + 32)); + long[] callResult_18 = instance.getMachine().call(1652, callArgs_18); + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) 10); + callArgs_19[0] = ((long) (local8 + 32)); + instance.getMachine().call(1660, callArgs_19); + memory.writeI32((int) ((local8 + 48) + 8) < 0 ? ((local8 + 48) + 8) : ((local8 + 48) + 8) + 0, (int) 0); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 48, (long) 0L); + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_16; + } + long[] callArgs_20 = new long[4]; + callArgs_20[3] = ((long) (local8 + 48)); + callArgs_20[2] = ((long) arg7); + callArgs_20[1] = ((long) local12); + callArgs_20[0] = ((long) arg3); + long[] callResult_20 = instance.getMachine().call(182, callArgs_20); + label_17: { + local11 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 59) & 0xFF); + _snap_0 = local11; + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local11, 0) != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 52) : (_snap_0 & 255))) != 0) { + break label_17; + } + long[] callArgs_21 = new long[3]; + callArgs_21[2] = ((long) (local15 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 68) : (arg1 & 255))); + callArgs_21[1] = ((long) (local15 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 64) : (local8 + 64))); + callArgs_21[0] = ((long) (local8 + 32)); + long[] callResult_21 = instance.getMachine().call(1652, callArgs_21); + arg1 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 59) & 0xFF); + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0); + long[] callArgs_22 = new long[3]; + callArgs_22[2] = ((long) (local11 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 52) : arg1)); + callArgs_22[1] = ((long) (local11 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 48) : (local8 + 48))); + callArgs_22[0] = ((long) (local8 + 32)); + long[] callResult_22 = instance.getMachine().call(1652, callArgs_22); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) 10); + callArgs_23[0] = ((long) (local8 + 32)); + instance.getMachine().call(1660, callArgs_23); + arg1 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 75) & 0xFF); + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0); + long[] callArgs_24 = new long[3]; + callArgs_24[2] = ((long) (local11 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 68) : arg1)); + callArgs_24[1] = ((long) (local11 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 64) : (local8 + 64))); + callArgs_24[0] = ((long) (local8 + 32)); + long[] callResult_24 = instance.getMachine().call(1652, callArgs_24); + local12 = memory.readInt((int) (local9 + 20) < 0 ? (local9 + 20) : (local9 + 20) + 0); + local13 = memory.readInt((int) local8 < 0 ? local8 : local8 + 52); + arg1 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 59) & 0xFF); + local11 = memory.readInt((int) (local9 + 16) < 0 ? (local9 + 16) : (local9 + 16) + 0); + local14 = memory.readInt((int) local8 < 0 ? local8 : local8 + 60); + local14 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local11, local14) != 0 ? (local11 + (local14 ^ -1)) : 0); + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) 32); + callArgs_25[1] = ((long) local14); + callArgs_25[0] = ((long) (local8 + 32)); + long[] callResult_25 = instance.getMachine().call(1661, callArgs_25); + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) (((int) memory.read((int) arg4 < 0 ? arg4 : arg4 + 4) & 0xFF) != 0 ? 13056 : 38861)); + callArgs_26[0] = ((long) (local8 + 32)); + long[] callResult_26 = instance.getMachine().call(1662, callArgs_26); + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) (((int) memory.read((int) arg4 < 0 ? arg4 : arg4 + 4) & 0xFF) != 0 ? 13050 : 38861)); + callArgs_27[0] = ((long) (local8 + 32)); + long[] callResult_27 = instance.getMachine().call(1662, callArgs_27); + arg1 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0) != 0 ? local13 : arg1) - local14); + local11 = (local12 - local11); + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, local11) != 0 ? arg1 : local11); + long[] callArgs_28 = new long[3]; + callArgs_28[2] = ((long) 94); + callArgs_28[1] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 1) != 0 ? arg1 : 1)); + callArgs_28[0] = ((long) (local8 + 32)); + long[] callResult_28 = instance.getMachine().call(1661, callArgs_28); + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) (((int) memory.read((int) arg4 < 0 ? arg4 : arg4 + 4) & 0xFF) != 0 ? 13067 : 38861)); + callArgs_29[0] = ((long) (local8 + 32)); + long[] callResult_29 = instance.getMachine().call(1662, callArgs_29); + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) 10); + callArgs_30[0] = ((long) (local8 + 32)); + instance.getMachine().call(1660, callArgs_30); + local11 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 59) & 0xFF); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local11), -1) != 0) { + break label_16; + } + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 48)); + instance.getMachine().call(1777, callArgs_31); + } + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local8 < 0 ? local8 : local8 + 75), -1) != 0) { + break label_18; + } + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 64)); + instance.getMachine().call(1777, callArgs_32); + } + arg1 = (int) (byte) memory.read((int) local8 < 0 ? local8 : local8 + 43); + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0); + long[] callArgs_33 = new long[3]; + callArgs_33[2] = ((long) (local11 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 36) : (arg1 & 255))); + callArgs_33[1] = ((long) (local11 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 32) : (local8 + 32))); + callArgs_33[0] = ((long) arg0); + long[] callResult_33 = instance.getMachine().call(1652, callArgs_33); + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local8 < 0 ? local8 : local8 + 43), -1) != 0) { + break label_19; + } + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 32)); + instance.getMachine().call(1777, callArgs_34); + } + local9 = (local9 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local10, local9) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + instance.global(0).setValue(((long) (local8 + 80))); + return; + } + + public static long[] call_87(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int arg7 = ((int) args[7]); + Wat2WasmMachine.func_87(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, memory, instance); + return null; + } + + public static void func_88(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + local7 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local7)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 1); + callArgs_0[1] = ((long) arg3); + callArgs_0[0] = ((long) (local7 + 24)); + long[] callResult_0 = instance.getMachine().call(86, callArgs_0); + long[] callArgs_1 = new long[8]; + callArgs_1[7] = ((long) arg6); + callArgs_1[6] = ((long) arg5); + callArgs_1[5] = ((long) arg4); + callArgs_1[4] = ((long) ((int) callResult_0[0])); + callArgs_1[3] = ((long) arg2); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) arg0); + callArgs_1[0] = ((long) (local7 + 8)); + instance.getMachine().call(87, callArgs_1); + arg6 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 19) & 0xFF); + arg5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg6), 0); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) arg3); + callArgs_2[2] = ((long) (arg5 != 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 12) : arg6)); + callArgs_2[1] = ((long) 1); + callArgs_2[0] = ((long) (arg5 != 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 8) : (local7 + 8))); + long[] callResult_2 = instance.getMachine().call(1856, callArgs_2); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local7 < 0 ? local7 : local7 + 19), -1) != 0) { + break label_1; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 8)); + instance.getMachine().call(1777, callArgs_3); + } + instance.global(0).setValue(((long) (local7 + 32))); + return; + } + + public static long[] call_88(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + Wat2WasmMachine.func_88(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + return null; + } + + public static void func_89(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 39876); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 12); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local2); + callArgs_0[2] = ((long) 14385); + callArgs_0[1] = ((long) 7851); + callArgs_0[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_0); + label_1: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + int ciTableIdx_1 = (int) (local3); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 39956); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 13); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local2); + callArgs_2[2] = ((long) 8197); + callArgs_2[1] = ((long) 8161); + callArgs_2[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_2); + label_2: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + int ciTableIdx_3 = (int) (local3); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40036); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 14); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local2); + callArgs_4[2] = ((long) 7776); + callArgs_4[1] = ((long) 6699); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_4); + label_3: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + int ciTableIdx_5 = (int) (local3); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40116); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 15); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) local2); + callArgs_6[2] = ((long) 7818); + callArgs_6[1] = ((long) 12785); + callArgs_6[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_6); + label_4: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_4; + } + int ciTableIdx_7 = (int) (local3); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 16); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) local2); + callArgs_8[2] = ((long) 6066); + callArgs_8[1] = ((long) 17852); + callArgs_8[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_8); + label_5: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_5; + } + int ciTableIdx_9 = (int) (local3); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40276); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 17); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_10 = new long[4]; + callArgs_10[3] = ((long) local2); + callArgs_10[2] = ((long) 6041); + callArgs_10[1] = ((long) 8750); + callArgs_10[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_10); + label_6: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_6; + } + int ciTableIdx_11 = (int) (local3); + int ciFuncId_11 = instance.table(0).requiredRef(ciTableIdx_11); + com.dylibso.chicory.runtime.Instance ciRefInstance_11 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_11), instance); + if (!ciRefInstance_11.type(ciRefInstance_11.functionType(ciFuncId_11)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_11.getMachine().call(ciFuncId_11, callArgs_11); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40356); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 18); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_12 = new long[4]; + callArgs_12[3] = ((long) local2); + callArgs_12[2] = ((long) 8706); + callArgs_12[1] = ((long) 8679); + callArgs_12[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_12); + label_7: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_7; + } + int ciTableIdx_13 = (int) (local3); + int ciFuncId_13 = instance.table(0).requiredRef(ciTableIdx_13); + com.dylibso.chicory.runtime.Instance ciRefInstance_13 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_13), instance); + if (!ciRefInstance_13.type(ciRefInstance_13.functionType(ciFuncId_13)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_13.getMachine().call(ciFuncId_13, callArgs_13); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40436); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 19); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_14 = new long[4]; + callArgs_14[3] = ((long) local2); + callArgs_14[2] = ((long) 15291); + callArgs_14[1] = ((long) 15271); + callArgs_14[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_14); + label_8: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_8; + } + int ciTableIdx_15 = (int) (local3); + int ciFuncId_15 = instance.table(0).requiredRef(ciTableIdx_15); + com.dylibso.chicory.runtime.Instance ciRefInstance_15 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_15), instance); + if (!ciRefInstance_15.type(ciRefInstance_15.functionType(ciFuncId_15)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_15.getMachine().call(ciFuncId_15, callArgs_15); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40516); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 20); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_16 = new long[4]; + callArgs_16[3] = ((long) local2); + callArgs_16[2] = ((long) 6016); + callArgs_16[1] = ((long) 13296); + callArgs_16[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_16); + label_9: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_9; + } + int ciTableIdx_17 = (int) (local3); + int ciFuncId_17 = instance.table(0).requiredRef(ciTableIdx_17); + com.dylibso.chicory.runtime.Instance ciRefInstance_17 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_17), instance); + if (!ciRefInstance_17.type(ciRefInstance_17.functionType(ciFuncId_17)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_17.getMachine().call(ciFuncId_17, callArgs_17); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40596); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 21); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_18 = new long[4]; + callArgs_18[3] = ((long) local2); + callArgs_18[2] = ((long) 8049); + callArgs_18[1] = ((long) 1122); + callArgs_18[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_18); + label_10: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_10; + } + int ciTableIdx_19 = (int) (local3); + int ciFuncId_19 = instance.table(0).requiredRef(ciTableIdx_19); + com.dylibso.chicory.runtime.Instance ciRefInstance_19 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_19), instance); + if (!ciRefInstance_19.type(ciRefInstance_19.functionType(ciFuncId_19)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_19.getMachine().call(ciFuncId_19, callArgs_19); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40676); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 22); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_20 = new long[4]; + callArgs_20[3] = ((long) local2); + callArgs_20[2] = ((long) 30273); + callArgs_20[1] = ((long) 8457); + callArgs_20[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_20); + label_11: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_11; + } + int ciTableIdx_21 = (int) (local3); + int ciFuncId_21 = instance.table(0).requiredRef(ciTableIdx_21); + com.dylibso.chicory.runtime.Instance ciRefInstance_21 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_21), instance); + if (!ciRefInstance_21.type(ciRefInstance_21.functionType(ciFuncId_21)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_21.getMachine().call(ciFuncId_21, callArgs_21); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40756); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 23); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_22 = new long[4]; + callArgs_22[3] = ((long) local2); + callArgs_22[2] = ((long) 2432); + callArgs_22[1] = ((long) 8030); + callArgs_22[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_22); + label_12: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_12; + } + int ciTableIdx_23 = (int) (local3); + int ciFuncId_23 = instance.table(0).requiredRef(ciTableIdx_23); + com.dylibso.chicory.runtime.Instance ciRefInstance_23 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_23), instance); + if (!ciRefInstance_23.type(ciRefInstance_23.functionType(ciFuncId_23)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_23.getMachine().call(ciFuncId_23, callArgs_23); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40836); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 24); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_24 = new long[4]; + callArgs_24[3] = ((long) local2); + callArgs_24[2] = ((long) 26696); + callArgs_24[1] = ((long) 26675); + callArgs_24[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_24); + label_13: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_13; + } + int ciTableIdx_25 = (int) (local3); + int ciFuncId_25 = instance.table(0).requiredRef(ciTableIdx_25); + com.dylibso.chicory.runtime.Instance ciRefInstance_25 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_25), instance); + if (!ciRefInstance_25.type(ciRefInstance_25.functionType(ciFuncId_25)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_25.getMachine().call(ciFuncId_25, callArgs_25); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40916); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 25); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_26 = new long[4]; + callArgs_26[3] = ((long) local2); + callArgs_26[2] = ((long) 12642); + callArgs_26[1] = ((long) 26506); + callArgs_26[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_26); + label_14: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_14; + } + int ciTableIdx_27 = (int) (local3); + int ciFuncId_27 = instance.table(0).requiredRef(ciTableIdx_27); + com.dylibso.chicory.runtime.Instance ciRefInstance_27 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_27), instance); + if (!ciRefInstance_27.type(ciRefInstance_27.functionType(ciFuncId_27)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_27.getMachine().call(ciFuncId_27, callArgs_27); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 40996); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 26); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_28 = new long[4]; + callArgs_28[3] = ((long) local2); + callArgs_28[2] = ((long) 1182); + callArgs_28[1] = ((long) 27752); + callArgs_28[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_28); + label_15: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_15; + } + int ciTableIdx_29 = (int) (local3); + int ciFuncId_29 = instance.table(0).requiredRef(ciTableIdx_29); + com.dylibso.chicory.runtime.Instance ciRefInstance_29 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_29), instance); + if (!ciRefInstance_29.type(ciRefInstance_29.functionType(ciFuncId_29)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_29.getMachine().call(ciFuncId_29, callArgs_29); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 41076); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 27); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_30 = new long[4]; + callArgs_30[3] = ((long) local2); + callArgs_30[2] = ((long) 1162); + callArgs_30[1] = ((long) 1142); + callArgs_30[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_30); + label_16: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_16; + } + int ciTableIdx_31 = (int) (local3); + int ciFuncId_31 = instance.table(0).requiredRef(ciTableIdx_31); + com.dylibso.chicory.runtime.Instance ciRefInstance_31 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_31), instance); + if (!ciRefInstance_31.type(ciRefInstance_31.functionType(ciFuncId_31)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_31.getMachine().call(ciFuncId_31, callArgs_31); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 41156); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 28); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_32 = new long[4]; + callArgs_32[3] = ((long) local2); + callArgs_32[2] = ((long) 8080); + callArgs_32[1] = ((long) 5841); + callArgs_32[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_32); + label_17: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + int ciTableIdx_33 = (int) (local3); + int ciFuncId_33 = instance.table(0).requiredRef(ciTableIdx_33); + com.dylibso.chicory.runtime.Instance ciRefInstance_33 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_33), instance); + if (!ciRefInstance_33.type(ciRefInstance_33.functionType(ciFuncId_33)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_33.getMachine().call(ciFuncId_33, callArgs_33); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 41236); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 29); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_34 = new long[4]; + callArgs_34[3] = ((long) local2); + callArgs_34[2] = ((long) 27128); + callArgs_34[1] = ((long) 17865); + callArgs_34[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_34); + label_18: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_18; + } + int ciTableIdx_35 = (int) (local3); + int ciFuncId_35 = instance.table(0).requiredRef(ciTableIdx_35); + com.dylibso.chicory.runtime.Instance ciRefInstance_35 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_35), instance); + if (!ciRefInstance_35.type(ciRefInstance_35.functionType(ciFuncId_35)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_35.getMachine().call(ciFuncId_35, callArgs_35); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 41316); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 30); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_36 = new long[4]; + callArgs_36[3] = ((long) local2); + callArgs_36[2] = ((long) 8396); + callArgs_36[1] = ((long) 8335); + callArgs_36[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_36); + label_19: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_19; + } + int ciTableIdx_37 = (int) (local3); + int ciFuncId_37 = instance.table(0).requiredRef(ciTableIdx_37); + com.dylibso.chicory.runtime.Instance ciRefInstance_37 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_37), instance); + if (!ciRefInstance_37.type(ciRefInstance_37.functionType(ciFuncId_37)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_37 = new long[1]; + callArgs_37[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_37.getMachine().call(ciFuncId_37, callArgs_37); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) 41396); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 31); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + long[] callArgs_38 = new long[4]; + callArgs_38[3] = ((long) local2); + callArgs_38[2] = ((long) 8437); + callArgs_38[1] = ((long) 13323); + callArgs_38[0] = ((long) arg1); + instance.getMachine().call(201, callArgs_38); + label_20: { + arg0 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_20; + } + int ciTableIdx_39 = (int) (arg0); + int ciFuncId_39 = instance.table(0).requiredRef(ciTableIdx_39); + com.dylibso.chicory.runtime.Instance ciRefInstance_39 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_39), instance); + if (!ciRefInstance_39.type(ciRefInstance_39.functionType(ciFuncId_39)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_39 = new long[1]; + callArgs_39[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_39.getMachine().call(ciFuncId_39, callArgs_39); + } + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_89(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_89(arg0, arg1, memory, instance); + return null; + } + + public static void func_90(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) (1)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF))); + return; + } + + public static long[] call_90(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_90(arg0, memory, instance); + return null; + } + + public static void func_91(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 1, (byte) (0)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_91(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_91(arg0, memory, instance); + return null; + } + + public static void func_92(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 2, (byte) (0)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_92(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_92(arg0, memory, instance); + return null; + } + + public static void func_93(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (0)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_93(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_93(arg0, memory, instance); + return null; + } + + public static void func_94(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 4, (byte) (0)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_94(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_94(arg0, memory, instance); + return null; + } + + public static void func_95(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 5, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_95(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_95(arg0, memory, instance); + return null; + } + + public static void func_96(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 6, (byte) (1)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF))); + return; + } + + public static long[] call_96(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_96(arg0, memory, instance); + return null; + } + + public static void func_97(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 7, (byte) (0)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_97(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_97(arg0, memory, instance); + return null; + } + + public static void func_98(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 8, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_98(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_98(arg0, memory, instance); + return null; + } + + public static void func_99(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeShort((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 9, (short) (0)); + return; + } + + public static long[] call_99(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_99(arg0, memory, instance); + return null; + } + + public static void func_100(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF)) & com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF) | ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)))))); + return; + } + + public static long[] call_100(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_100(arg0, memory, instance); + return null; + } + + public static void func_101(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_101(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_101(arg0, memory, instance); + return null; + } + + public static void func_102(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 12, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_102(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_102(arg0, memory, instance); + return null; + } + + public static void func_103(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 13, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_103(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_103(arg0, memory, instance); + return null; + } + + public static void func_104(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 14, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_104(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_104(arg0, memory, instance); + return null; + } + + public static void func_105(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 15, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_105(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_105(arg0, memory, instance); + return null; + } + + public static void func_106(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 16, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_106(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_106(arg0, memory, instance); + return null; + } + + public static void func_107(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 17, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_107(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_107(arg0, memory, instance); + return null; + } + + public static void func_108(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 18, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (1)); + } + label_3: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 9) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 10, (byte) (0)); + } + return; + } + + public static long[] call_108(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_108(arg0, memory, instance); + return null; + } + + public static void func_109(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 72340172838076673L); + memory.writeI32((int) (arg0 + 15) < 0 ? (arg0 + 15) : (arg0 + 15) + 0, (int) 16843009); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) 72340172838076673L); + return; + } + + public static long[] call_109(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_109(arg0, memory, instance); + return null; + } + + public static void func_110(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + label_1: { + label_2: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (local3 != 0) { + break label_2; + } + local4 = -1; + break label_1; + } + local5 = (local2 + -1); + arg1 = local3; + label_3: while (true) { + label_4: { + if (arg1 != 0) { + break label_4; + } + local4 = -1; + break label_1; + } + local6 = (local5 + arg1); + local4 = (arg1 + -1); + arg1 = local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(46, ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0 ? local3 : local4)); + return; + } + + public static long[] call_110(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_110(arg0, arg1, memory, instance); + return null; + } + + public static void func_111(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local4 = local2; + label_3: { + label_4: while (true) { + label_5: { + if (local4 != 0) { + break label_5; + } + local4 = -1; + break label_3; + } + local4 = (local4 + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(47, ((int) memory.read((int) (local4 + local3) < 0 ? (local4 + local3) : (local4 + local3) + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + local5 = local2; + label_6: { + label_7: while (true) { + label_8: { + if (local5 != 0) { + break label_8; + } + local5 = -1; + break label_6; + } + local5 = (local5 + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(92, ((int) memory.read((int) (local5 + local3) < 0 ? (local5 + local3) : (local5 + local3) + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, (local5 & local4)) != 0) { + break label_1; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + label_9: { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local5) != 0) { + break label_9; + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, local5) != 0 ? local4 : (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, local5) != 0 ? local4 : local5)); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local2, local5) != 0) { + break label_11; + } + local5 = (local5 + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 - local5)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local3 + local5)); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_111(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_111(arg0, arg1, memory, instance); + return null; + } + + public static void func_112(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)) != 0) { + break label_1; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) 0); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 16)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(113, callArgs_0); + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 16); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 20); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) 1); + callArgs_1[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, local3) != 0 ? 0 : (62 - (com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ(((local3 - arg0) >> 2)) << 1)))); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(114, callArgs_1); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) arg1); + label_2: { + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_2 = (int) (arg1); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (int) local4); + long[] callResult_2 = ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) ((int) callResult_2[0])); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) (local2 + 16)); + callArgs_3[0] = ((long) local2); + instance.getMachine().call(115, callArgs_3); + label_3: { + arg1 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 12) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 12) : memory.readInt((int) local2 < 0 ? local2 : local2 + 12) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + int ciTableIdx_4 = (int) (arg1); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 32))); + return; + } + + public static long[] call_112(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_112(arg0, arg1, memory, instance); + return null; + } + + public static void func_113(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + local4 = 1; + label_4: while (true) { + local5 = local2; + local6 = local4; + local4 = 1; + local2 = local3; + label_5: { + local7 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 19) & 0xFF); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local7); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0); + local10 = (local9 != 0 ? memory.readInt((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0) : local7); + arg0 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 19) & 0xFF); + _snap_0 = arg0; + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((arg0 != 0 ? memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0) : _snap_0), local10) != 0) { + break label_5; + } + local11 = (local5 + 8); + local12 = (local3 + 8); + arg0 = (arg0 != 0 ? memory.readInt((int) local12 < 0 ? local12 : local12 + 0) : local12); + label_6: { + label_7: { + if (local9 != 0) { + break label_7; + } + local2 = local11; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_6; + } + label_8: while (true) { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF), ((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF)) != 0) { + break label_9; + } + local4 = 1; + local2 = local3; + break label_5; + } + arg0 = (arg0 + 1); + local2 = (local2 + 1); + local7 = (local7 + -1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_6; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_6; + } + local4 = 1; + local2 = local3; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local10); + callArgs_0[1] = ((long) arg0); + callArgs_0[0] = ((long) (local9 != 0 ? memory.readInt((int) local11 < 0 ? local11 : local11 + 0) : local11)); + long[] callResult_0 = instance.getMachine().call(1889, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_5; + } + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local6 & 1)) != 0) { + break label_10; + } + label_11: { + arg0 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, local2) != 0) { + break label_11; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local11); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (arg0 + 4)); + break label_10; + } + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = ((arg0 - local7) >> 2); + local4 = (local6 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 1073741824) != 0) { + break label_2; + } + label_12: { + label_13: { + local2 = (local2 - local7); + local9 = (local2 >>> 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local4) != 0 ? local9 : local4) : 1073741823); + if (local4 != 0) { + break label_13; + } + local9 = 0; + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 1073741824) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local4 << 2)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local9 = ((int) callResult_1[0]); + } + local2 = (local9 + (local6 << 2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local11); + local4 = (local9 + (local4 << 2)); + local9 = (local2 + 4); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, arg0) != 0) { + break label_14; + } + label_15: while (true) { + local2 = (local2 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_15; + } + break; + } + arg0 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local9); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_10; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + } + label_16: { + label_17: { + arg0 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, local2) != 0) { + break label_17; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local12); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (arg0 + 4)); + local4 = 0; + break label_16; + } + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = ((arg0 - local7) >> 2); + local4 = (local6 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 1073741824) != 0) { + break label_2; + } + label_18: { + label_19: { + local2 = (local2 - local7); + local9 = (local2 >>> 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local4) != 0 ? local9 : local4) : 1073741823); + if (local4 != 0) { + break label_19; + } + local9 = 0; + break label_18; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 1073741824) != 0) { + break label_1; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (local4 << 2)); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local9 = ((int) callResult_3[0]); + } + local2 = (local9 + (local6 << 2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local12); + local4 = (local9 + (local4 << 2)); + local9 = (local2 + 4); + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, arg0) != 0) { + break label_20; + } + label_21: while (true) { + local2 = (local2 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_21; + } + break; + } + arg0 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local9); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local2); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_16; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + } + local2 = local5; + } + local3 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_113(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_113(arg0, arg1, memory, instance); + return null; + } + + public static void func_114(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[17]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = arg2; + iL[3] = arg3; + label_1: while (true) { + iL[4] = (iL[1] + -8); + iL[5] = (iL[1] + -4); + iL[6] = (iL[1] + -12); + label_2: { + label_3: while (true) { + label_4: { + label_5: { + label_6: { + int _d0 = func_114__h0(iL, memory, instance); + if (_d0 == 1) + break label_2; + if (_d0 == 2) + break label_4; + if (_d0 == 3) + break label_5; + if (_d0 == 4) + return; + } + iL[0] = (iL[7] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[1]) != 0) { + break label_5; + } + label_68: while (true) { + iL[10] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[9] = memory.readInt((int) (iL[10] + 20) < 0 ? (iL[10] + 20) : (iL[10] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[8], iL[9]) != 0) { + break label_5; + } + label_69: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[9], iL[8]) != 0) { + break label_69; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 24), memory.readInt((int) (iL[10] + 24) < 0 ? (iL[10] + 24) : (iL[10] + 24) + 0)) != 0) { + break label_5; + } + } + iL[0] = (iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], iL[1]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_68; + } + break; + } + } + iL[10] = iL[1]; + label_70: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[1]) != 0) { + break label_70; + } + iL[9] = iL[4]; + label_71: { + label_72: while (true) { + label_73: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[8], iL[11]) != 0) { + break label_73; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[8]) != 0) { + break label_71; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 24), memory.readInt((int) (iL[12] + 24) < 0 ? (iL[12] + 24) : (iL[12] + 24) + 0)) != 0) { + break label_71; + } + } + iL[12] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0); + iL[11] = memory.readInt((int) (iL[12] + 20) < 0 ? (iL[12] + 20) : (iL[12] + 20) + 0); + iL[9] = (iL[9] + -4); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_72; + } + } + iL[10] = (iL[9] + 4); + } + label_74: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[10]) != 0) { + break label_74; + } + iL[8] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[12] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + label_75: while (true) { + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) iL[8]); + memory.writeI32((int) iL[10] < 0 ? iL[10] : iL[10] + 0, (int) iL[12]); + iL[11] = (iL[0] + 4); + label_76: { + label_77: { + iL[9] = memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 20); + iL[12] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + iL[8] = memory.readInt((int) (iL[12] + 20) < 0 ? (iL[12] + 20) : (iL[12] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[9], iL[8]) != 0) { + break label_77; + } + iL[0] = iL[11]; + break label_76; + } + iL[0] = iL[11]; + label_78: while (true) { + label_79: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[9]) != 0) { + break label_79; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 24), memory.readInt((int) (iL[12] + 24) < 0 ? (iL[12] + 24) : (iL[12] + 24) + 0)) != 0) { + break label_76; + } + } + iL[0] = (iL[0] + 4); + iL[12] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[8] = memory.readInt((int) (iL[12] + 20) < 0 ? (iL[12] + 20) : (iL[12] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[9], iL[8]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_78; + } + break; + } + } + label_80: while (true) { + iL[10] = (iL[10] + -4); + iL[8] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[11] = memory.readInt((int) (iL[8] + 20) < 0 ? (iL[8] + 20) : (iL[8] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[9], iL[11]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_80; + } + label_81: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[9]) != 0) { + break label_81; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 24), memory.readInt((int) (iL[8] + 24) < 0 ? (iL[8] + 24) : (iL[8] + 24) + 0)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_80; + } + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], iL[10]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_75; + } + break; + } + } + label_82: { + iL[9] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[7], iL[9]) != 0) { + break label_82; + } + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0)); + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) iL[13]); + iL[3] = 0; + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + iL[9] = 0; + label_83: { + label_84: while (true) { + label_85: { + iL[12] = (iL[7] + iL[9]); + iL[15] = (iL[12] + 4); + iL[10] = memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0); + iL[11] = memory.readInt((int) (iL[10] + 20) < 0 ? (iL[10] + 20) : (iL[10] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[11], iL[8]) != 0) { + break label_85; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[11]) != 0) { + break label_83; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[10] + 24) < 0 ? (iL[10] + 24) : (iL[10] + 24) + 0), memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 24)) != 0) { + break label_83; + } + } + iL[9] = (iL[9] + 4); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_84; + } + } + label_86: { + label_87: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + break label_87; + } + iL[14] = iL[5]; + iL[11] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0); + iL[9] = memory.readInt((int) (iL[11] + 20) < 0 ? (iL[11] + 20) : (iL[11] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[9], iL[8]) != 0) { + break label_86; + } + label_88: while (true) { + label_89: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[9]) != 0) { + break label_89; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) (iL[11] + 24) < 0 ? (iL[11] + 24) : (iL[11] + 24) + 0), memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 24)) != 0) { + break label_86; + } + } + iL[14] = (iL[14] + -4); + iL[11] = memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0); + iL[9] = memory.readInt((int) (iL[11] + 20) < 0 ? (iL[11] + 20) : (iL[11] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[9], iL[8]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_88; + } + break label_86; + } + } + iL[14] = iL[1]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[15], iL[1]) != 0) { + break label_86; + } + iL[14] = iL[5]; + iL[11] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0); + iL[9] = memory.readInt((int) (iL[11] + 20) < 0 ? (iL[11] + 20) : (iL[11] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[9], iL[8]) != 0) { + break label_86; + } + iL[14] = iL[5]; + label_90: while (true) { + label_91: { + label_92: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[9]) != 0) { + break label_92; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[15], iL[14]) != 0) { + break label_86; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[11] + 24) < 0 ? (iL[11] + 24) : (iL[11] + 24) + 0), memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 24)) != 0) { + break label_91; + } + break label_86; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[15], iL[14]) != 0) { + break label_86; + } + } + iL[14] = (iL[14] + -4); + iL[11] = memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0); + iL[9] = memory.readInt((int) (iL[11] + 20) < 0 ? (iL[11] + 20) : (iL[11] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[9], iL[8]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_90; + } + break; + } + } + label_93: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[15], iL[14]) != 0) { + break label_93; + } + iL[0] = memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0); + iL[9] = iL[15]; + iL[12] = iL[14]; + label_94: while (true) { + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) iL[0]); + memory.writeI32((int) iL[12] < 0 ? iL[12] : iL[12] + 0, (int) iL[10]); + iL[9] = (iL[9] + 4); + iL[8] = memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 20); + label_95: { + label_96: while (true) { + label_97: { + iL[10] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0); + iL[11] = memory.readInt((int) (iL[10] + 20) < 0 ? (iL[10] + 20) : (iL[10] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[11], iL[8]) != 0) { + break label_97; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[11]) != 0) { + break label_95; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[10] + 24) < 0 ? (iL[10] + 24) : (iL[10] + 24) + 0), memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 24)) != 0) { + break label_95; + } + } + iL[9] = (iL[9] + 4); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_96; + } + } + label_98: { + iL[12] = (iL[12] + -4); + iL[0] = memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0); + iL[11] = memory.readInt((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[11], iL[8]) != 0) { + break label_98; + } + label_99: while (true) { + label_100: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[11]) != 0) { + break label_100; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) (iL[0] + 24) < 0 ? (iL[0] + 24) : (iL[0] + 24) + 0), memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 24)) != 0) { + break label_98; + } + } + iL[12] = (iL[12] + -4); + iL[0] = memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0); + iL[11] = memory.readInt((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[11], iL[8]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_99; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[9], iL[12]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_94; + } + break; + } + iL[12] = (iL[9] + -4); + } + label_101: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[7], iL[12]) != 0) { + break label_101; + } + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0)); + } + memory.writeI32((int) iL[12] < 0 ? iL[12] : iL[12] + 0, (int) iL[13]); + label_102: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[15], iL[14]) != 0) { + break label_102; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) iL[12]); + callArgs_8[0] = ((long) iL[7]); + long[] callResult_8 = instance.getMachine().call(119, callArgs_8); + iL[9] = ((int) callResult_8[0]); + label_103: { + iL[0] = (iL[12] + 4); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) iL[1]); + callArgs_9[0] = ((long) iL[0]); + long[] callResult_9 = instance.getMachine().call(119, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_9[0])) != 0) { + break label_103; + } + iL[1] = iL[12]; + iL[0] = iL[7]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + break label_2; + } + if (iL[9] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + } + long[] callArgs_10 = new long[4]; + callArgs_10[3] = ((long) iL[16]); + callArgs_10[2] = ((long) iL[2]); + callArgs_10[1] = ((long) iL[12]); + callArgs_10[0] = ((long) iL[7]); + instance.getMachine().call(114, callArgs_10); + iL[0] = (iL[12] + 4); + iL[3] = 0; + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + } + break; + } + return; + } + + public static long[] call_114(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_114(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_115(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + label_1: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_1; + } + label_2: while (true) { + label_3: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local5) != 0) { + break label_3; + } + label_4: { + label_5: { + local7 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local8 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 11) & 0xFF); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local8), 0); + local10 = (local9 != 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 4) : local8); + if (local10 != 0) { + break label_5; + } + label_6: while (true) { + label_7: { + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local11 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local11); + if ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local12, 0) != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 4) : local11) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local12, 1) != 0) { + break label_3; + } + local12 = (local9 != 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 0) : local7); + label_8: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((int) memory.read((int) local12 < 0 ? local12 : local12 + 0) & 0xFF), ((int) memory.read((int) local8 < 0 ? local8 : local8 + 0) & 0xFF)) != 0) { + break label_7; + } + local12 = (local12 + 1); + local8 = (local8 + 1); + local11 = (local11 + -1); + if (local11 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_3; + } + } + local5 = (local5 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break label_4; + } + } + label_9: while (true) { + label_10: { + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local11 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + local13 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local11); + local14 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local13, 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local10, (local14 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 4) : local11)) != 0) { + break label_10; + } + local12 = (local9 != 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 0) : local7); + label_11: { + if (local14 != 0) { + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local13) != 0) { + break label_3; + } + label_12: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((int) memory.read((int) local12 < 0 ? local12 : local12 + 0) & 0xFF), ((int) memory.read((int) local8 < 0 ? local8 : local8 + 0) & 0xFF)) != 0) { + break label_10; + } + local12 = (local12 + 1); + local8 = (local8 + 1); + local11 = (local11 + -1); + if (local11 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break label_3; + } + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local10); + callArgs_0[1] = ((long) local12); + callArgs_0[0] = ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + long[] callResult_0 = instance.getMachine().call(1889, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_0[0])) != 0) { + break label_3; + } + } + local5 = (local5 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + local5 = local6; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_13; + } + int ciTableIdx_1 = (int) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 8)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(2))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + callArgs_1[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + callArgs_1[0] = ((long) arg2); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + } + local3 = (local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + return; + } + + public static long[] call_115(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_115(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_116(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (arg1 + 24); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 20)) != 0) { + break label_1; + } + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(120, callArgs_0); + arg1 = ((int) callResult_0[0]); + if (arg1 != 0) { + break label_2; + } + return -1; + } + local2 = (arg1 + 40); + } + return memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + } + + public static long[] call_116(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_116(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_117(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + label_2: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local4 = memory.readInt((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local6 = memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, local6) != 0) { + break label_2; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0), memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0)) != 0) { + break label_2; + } + } + label_4: { + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local6 = memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, local4) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local6) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0), memory.readInt((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0)) != 0) { + break label_1; + } + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local5); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local3); + label_5: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local5 = memory.readInt((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = memory.readInt((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, local3) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local5) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0), memory.readInt((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0)) != 0) { + break label_1; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local4); + return; + } + label_6: { + label_7: { + label_8: { + local6 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local7 = memory.readInt((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, local4) != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local7) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0), memory.readInt((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0)) != 0) { + break label_7; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + break label_6; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local5); + label_9: { + arg0 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, local3) != 0) { + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local4) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0), memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0)) != 0) { + break label_1; + } + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) arg0); + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local5); + } + return; + } + + public static long[] call_117(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_117(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_118(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(117, callArgs_0); + label_1: { + label_2: { + local5 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + local6 = memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0); + local7 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local8 = memory.readInt((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, local8) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local6) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0), memory.readInt((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0)) != 0) { + break label_1; + } + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local5); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) local7); + label_3: { + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local6 = memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local8 = memory.readInt((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, local8) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local6) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0), memory.readInt((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0)) != 0) { + break label_1; + } + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local5); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local7); + label_4: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local8 = memory.readInt((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, local8) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local6) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0), memory.readInt((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0)) != 0) { + break label_1; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local7); + } + label_5: { + label_6: { + local5 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0); + local6 = memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0); + local7 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + local8 = memory.readInt((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, local8) != 0) { + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local6) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0), memory.readInt((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0)) != 0) { + break label_5; + } + } + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) local5); + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 0, (int) local7); + label_7: { + arg4 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + local7 = memory.readInt((int) (arg4 + 20) < 0 ? (arg4 + 20) : (arg4 + 20) + 0); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local6 = memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, local6) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local7) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (arg4 + 24) < 0 ? (arg4 + 24) : (arg4 + 24) + 0), memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0)) != 0) { + break label_5; + } + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg4); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) local5); + label_8: { + arg3 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local5 = memory.readInt((int) (arg3 + 20) < 0 ? (arg3 + 20) : (arg3 + 20) + 0); + arg4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local7 = memory.readInt((int) (arg4 + 20) < 0 ? (arg4 + 20) : (arg4 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, local7) != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local5) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (arg3 + 24) < 0 ? (arg3 + 24) : (arg3 + 24) + 0), memory.readInt((int) (arg4 + 24) < 0 ? (arg4 + 24) : (arg4 + 24) + 0)) != 0) { + break label_5; + } + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) arg3); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg4); + label_9: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + arg4 = memory.readInt((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = memory.readInt((int) (arg3 + 20) < 0 ? (arg3 + 20) : (arg3 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg4, local5) != 0) { + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, arg4) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0), memory.readInt((int) (arg3 + 24) < 0 ? (arg3 + 24) : (arg3 + 24) + 0)) != 0) { + break label_5; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) arg3); + } + return; + } + + public static long[] call_118(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_118(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static int func_119(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local2 = 1; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + switch(((arg1 - arg0) >> 2)) { + case 0: + { + break label_1; + } + case 1: + { + break label_1; + } + case 2: + { + break label_6; + } + case 3: + { + break label_5; + } + case 4: + { + break label_4; + } + case 5: + { + break label_3; + } + default: + { + break label_2; + } + } + } + label_7: { + local3 = (arg1 + -4); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local5 = memory.readInt((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local7 = memory.readInt((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, local7) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local5) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0), memory.readInt((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0)) != 0) { + break label_1; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local6); + return 1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (arg1 + -4)); + callArgs_0[1] = ((long) (arg0 + 4)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(117, callArgs_0); + return 1; + } + local5 = (arg0 + 4); + local4 = (arg0 + 8); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(117, callArgs_1); + label_8: { + local7 = (arg1 + -4); + local6 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + local8 = memory.readInt((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local9 = memory.readInt((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, local9) != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, local8) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0), memory.readInt((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0)) != 0) { + break label_1; + } + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local6); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local3); + label_9: { + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local3 = memory.readInt((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local5 = memory.readInt((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, local5) != 0) { + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local3) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0), memory.readInt((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0)) != 0) { + break label_1; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local4); + label_10: { + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 20); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = memory.readInt((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, local5) != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local3) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0), memory.readInt((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0)) != 0) { + break label_1; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local4); + return 1; + } + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) (arg1 + -4)); + callArgs_2[3] = ((long) (arg0 + 12)); + callArgs_2[2] = ((long) (arg0 + 8)); + callArgs_2[1] = ((long) (arg0 + 4)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(118, callArgs_2); + return 1; + } + local6 = (arg0 + 8); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local6); + callArgs_3[1] = ((long) (arg0 + 4)); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(117, callArgs_3); + local4 = (arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_1; + } + local10 = 0; + local11 = 0; + label_11: while (true) { + label_12: { + label_13: { + local9 = local4; + local5 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + local2 = memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0); + local4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local3 = memory.readInt((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local2, local3) != 0) { + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0), memory.readInt((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0)) != 0) { + break label_12; + } + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) local4); + local4 = arg0; + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, local6) != 0) { + break label_14; + } + local4 = local10; + label_15: { + label_16: while (true) { + label_17: { + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local3 = (arg0 + local4); + local2 = memory.readInt((int) (local3 + 4) < 0 ? (local3 + 4) : (local3 + 4) + 0); + local8 = memory.readInt((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, local8) != 0) { + break label_17; + } + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local7) != 0) { + break label_18; + } + local4 = local6; + break label_14; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) local5 < 0 ? local5 : local5 + 24), memory.readInt((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0)) != 0) { + break label_15; + } + } + local6 = (local6 + -4); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) local2); + local4 = (local4 + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-8, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + break; + } + local4 = arg0; + break label_14; + } + local4 = (local3 + 8); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local5); + local11 = (local11 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, local11) != 0) { + break label_12; + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, (local9 + 4)); + } + local10 = (local10 + 4); + local6 = local9; + local4 = (local9 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + local2 = 1; + } + return local2; + } + + public static long[] call_119(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_119(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_120(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11) & 0xFF); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0); + local4 = (local3 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : local2); + local2 = local4; + local5 = (local3 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : arg1); + arg1 = local5; + local3 = local4; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 4) != 0) { + break label_1; + } + label_2: { + label_3: { + local3 = (local4 + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local3 & 4)) != 0) { + break label_3; + } + local6 = local4; + arg1 = local5; + local2 = local4; + break label_2; + } + arg1 = (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) * 1540483477); + local2 = ((((arg1 >>> 24) ^ arg1) * 1540483477) ^ (local4 * 1540483477)); + arg1 = (local5 + 4); + local6 = local3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 4) != 0) { + break label_1; + } + local3 = local6; + label_4: while (true) { + local6 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) * 1540483477); + _snap_0 = local6; + local6 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) * 1540483477); + local2 = ((((_snap_0 >>> 24) ^ _snap_0) * 1540483477) ^ (((((local6 >>> 24) ^ local6) * 1540483477) ^ (local2 * 1540483477)) * 1540483477)); + arg1 = (arg1 + 8); + local3 = (local3 + -8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + label_5: { + label_6: { + label_7: { + label_8: { + switch((local3 + -1)) { + case 0: + { + break label_6; + } + case 1: + { + break label_7; + } + case 2: + { + break label_8; + } + default: + { + break label_5; + } + } + } + local2 = ((((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 2) & 0xFF) << 16) ^ local2); + } + local2 = ((((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 1) & 0xFF) << 8) ^ local2); + } + local2 = ((local2 ^ ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)) * 1540483477); + } + local6 = 0; + label_9: { + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_9; + } + arg1 = (((local2 >>> 13) ^ local2) * 1540483477); + local3 = ((arg1 >>> 15) ^ arg1); + label_10: { + label_11: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 1) != 0) { + break label_11; + } + local8 = (local3 & (local7 + -1)); + break label_10; + } + local8 = local3; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local7) != 0) { + break label_10; + } + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local3, local7); + } + arg1 = memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local8 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local8 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local8 << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_9; + } + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_9; + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 2) != 0) { + break label_12; + } + label_13: while (true) { + label_14: { + label_15: { + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local3) != 0) { + break label_15; + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, local7) != 0) { + break label_16; + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local2, local7); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local2) != 0) { + break label_14; + } + return 0; + } + local6 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 19) & 0xFF); + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg0, 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, (local2 != 0 ? memory.readInt((int) (arg1 + 12) < 0 ? (arg1 + 12) : (arg1 + 12) + 0) : local6)) != 0) { + break label_14; + } + label_17: { + label_18: { + label_19: { + if (local2 != 0) { + break label_19; + } + if (arg0 != 0) { + break label_18; + } + return arg1; + } + if (local4 != 0) { + break label_17; + } + return arg1; + } + local2 = 0; + label_20: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((int) memory.read((int) (local5 + local2) < 0 ? (local5 + local2) : (local5 + local2) + 0) & 0xFF), ((int) memory.read((int) ((arg1 + local2) + 8) < 0 ? ((arg1 + local2) + 8) : ((arg1 + local2) + 8) + 0) & 0xFF)) != 0) { + break label_14; + } + local2 = (local2 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + return arg1; + } + local6 = (arg1 + 8); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local4); + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) (local2 != 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : local6)); + long[] callResult_0 = instance.getMachine().call(1889, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_14; + } + return arg1; + } + local6 = 0; + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break label_9; + } + } + arg0 = (local7 + -1); + label_21: while (true) { + label_22: { + label_23: { + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local3) != 0) { + break label_23; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, (local2 & arg0)) != 0) { + break label_22; + } + return 0; + } + local6 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 19) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, (local2 != 0 ? memory.readInt((int) (arg1 + 12) < 0 ? (arg1 + 12) : (arg1 + 12) + 0) : local6)) != 0) { + break label_22; + } + label_24: { + if (local2 != 0) { + break label_24; + } + label_25: { + if (local7 != 0) { + break label_25; + } + return arg1; + } + local2 = 0; + label_26: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((int) memory.read((int) (local5 + local2) < 0 ? (local5 + local2) : (local5 + local2) + 0) & 0xFF), ((int) memory.read((int) ((arg1 + local2) + 8) < 0 ? ((arg1 + local2) + 8) : ((arg1 + local2) + 8) + 0) & 0xFF)) != 0) { + break label_22; + } + local2 = (local2 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_26; + } + break; + } + return arg1; + } + label_27: { + if (local4 != 0) { + break label_27; + } + return arg1; + } + local6 = (arg1 + 8); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) (local2 != 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : local6)); + long[] callResult_1 = instance.getMachine().call(1889, callArgs_1); + if (((int) callResult_1[0]) != 0) { + break label_22; + } + return arg1; + } + local6 = 0; + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_21; + } + break; + } + } + return local6; + } + + public static long[] call_120(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_120(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_121(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 228)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_121(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_121(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_122(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 248)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_122(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_122(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_123(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 308)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_123(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_123(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_124(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 328)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_124(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_124(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_125(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 288)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_125(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_125(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_126(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 208)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_126(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_126(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_127(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 348)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_127(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_127(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_128(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 368)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_128(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_128(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_129(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + long local5 = 0L; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_3; + } + local5 = memory.readLong((int) local3 < 0 ? local3 : local3 + 0); + local6 = (int) (local5 >>> 32L); + local7 = (int) local5; + local8 = 1; + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((local4 - local3), 9) != 0) { + break label_4; + } + local9 = 1; + local8 = 1; + label_5: while (true) { + label_6: { + label_7: { + local10 = (local9 << 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, memory.readInt((int) (local3 + local10) < 0 ? (local3 + local10) : (local3 + local10) + 0)) != 0) { + break label_7; + } + label_8: { + label_9: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, local3) != 0) { + break label_9; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local6) << 32L) | com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local7))); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + 12)); + break label_8; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local4), 12); + local12 = (local11 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local12, 357913942) != 0) { + break label_2; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 12); + local13 = (local3 << 1); + local3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local13, local12) != 0 ? local13 : local12) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 357913942) != 0) { + break label_1; + } + local12 = (local3 * 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local12); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local13 = ((int) callResult_0[0]); + local3 = (local13 + (local11 * 12)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local6) << 32L) | com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local7))); + local8 = (local13 + local12); + local7 = (local3 + 12); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_10; + } + label_11: while (true) { + local3 = (local3 + -12); + local2 = (local2 + -12); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_8; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_1); + } + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local5 = memory.readLong((int) (local3 + local10) < 0 ? (local3 + local10) : (local3 + local10) + 0); + local7 = (int) local5; + local6 = (int) (local5 >>> 32L); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local8 = 1; + break label_6; + } + local8 = (local8 + 1); + } + local9 = (local9 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, ((local4 - local3) >> 3)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + label_12: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, local3) != 0) { + break label_12; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local6) << 32L) | com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local7))); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + 12)); + return; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local4), 12); + local9 = (local10 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 357913942) != 0) { + break label_2; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 12); + arg1 = (local3 << 1); + local3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, local9) != 0 ? arg1 : local9) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 357913942) != 0) { + break label_1; + } + local9 = (local3 * 12); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local9); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + local3 = (arg1 + (local10 * 12)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local6) << 32L) | com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local7))); + local9 = (arg1 + local9); + local8 = (local3 + 12); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_13; + } + label_14: while (true) { + local3 = (local3 + -12); + local2 = (local2 + -12); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_129(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_129(arg0, arg1, memory, instance); + return null; + } + + public static int func_130(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + local1 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, local2) != 0) { + break label_1; + } + label_2: while (true) { + local1 = (memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0) + local1); + local2 = (local2 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg0, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + return local1; + } + + public static long[] call_130(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_130(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_131(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 20) != 0) { + break label_1; + } + return memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 128)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_131(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_131(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_132(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + local2 = 0; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 288)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + arg1 = ((int) callResult_0[0]); + _snap_0 = arg0; + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, ((memory.readInt((int) (_snap_0 + 128) < 0 ? (_snap_0 + 128) : (_snap_0 + 128) + 0) - arg0) >> 2)) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (arg0 + (arg1 << 2)) < 0 ? (arg0 + (arg1 << 2)) : (arg0 + (arg1 << 2)) + 0); + local2 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36) != 0 ? 0 : arg0); + } + return local2; + } + + public static long[] call_132(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_132(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_133(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + local2 = 0; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 288)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + arg1 = ((int) callResult_0[0]); + _snap_0 = arg0; + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, ((memory.readInt((int) (_snap_0 + 128) < 0 ? (_snap_0 + 128) : (_snap_0 + 128) + 0) - arg0) >> 2)) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (arg0 + (arg1 << 2)) < 0 ? (arg0 + (arg1 << 2)) : (arg0 + (arg1 << 2)) + 0); + local2 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36) != 0 ? 0 : arg0); + } + return local2; + } + + public static long[] call_133(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_133(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_134(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + local2 = memory.readInt((int) (arg0 + 128) < 0 ? (arg0 + 128) : (arg0 + 128) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_1; + } + arg0 = ((local2 - local3) >> 2); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 1) != 0 ? arg0 : 1); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - local5); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12); + local8 = (memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0) - local7); + local9 = 0; + label_2: while (true) { + label_3: { + local10 = memory.readInt((int) (local3 + (local9 << 2)) < 0 ? (local3 + (local9 << 2)) : (local3 + (local9 << 2)) + 0); + if (memory.readInt((int) local10 < 0 ? local10 : local10 + 36) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_3; + } + local2 = memory.readInt((int) (local10 + 44) < 0 ? (local10 + 44) : (local10 + 44) + 0); + arg1 = memory.readInt((int) local10 < 0 ? local10 : local10 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, (local2 - arg1)) != 0) { + break label_3; + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, arg1) != 0) { + break label_4; + } + arg0 = local5; + label_5: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0), memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0) { + break label_3; + } + arg0 = (arg0 + 8); + arg1 = (arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + local2 = memory.readInt((int) (local10 + 56) < 0 ? (local10 + 56) : (local10 + 56) + 0); + arg1 = memory.readInt((int) (local10 + 52) < 0 ? (local10 + 52) : (local10 + 52) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, (local2 - arg1)) != 0) { + break label_3; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, arg1) != 0) { + break label_6; + } + return local9; + } + arg0 = local7; + label_7: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0), memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0) { + break label_3; + } + arg0 = (arg0 + 8); + arg1 = (arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + return local9; + } + local9 = (local9 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local9) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + return -1; + } + + public static long[] call_134(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_134(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_135(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 4)); + callArgs_0[0] = ((long) (arg0 + 288)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return ((int) callResult_0[0]); + } + label_2: { + local2 = memory.readInt((int) (arg0 + 128) < 0 ? (arg0 + 128) : (arg0 + 128) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_2; + } + arg0 = ((local2 - local3) >> 2); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 1) != 0 ? arg0 : 1); + local5 = memory.readInt((int) (arg1 + 52) < 0 ? (arg1 + 52) : (arg1 + 52) + 0); + local6 = (memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0) - local5); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 40); + local8 = (memory.readInt((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0) - local7); + local9 = 0; + label_3: while (true) { + label_4: { + local10 = memory.readInt((int) (local3 + (local9 << 2)) < 0 ? (local3 + (local9 << 2)) : (local3 + (local9 << 2)) + 0); + if (memory.readInt((int) local10 < 0 ? local10 : local10 + 36) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_4; + } + local2 = memory.readInt((int) (local10 + 44) < 0 ? (local10 + 44) : (local10 + 44) + 0); + arg1 = memory.readInt((int) local10 < 0 ? local10 : local10 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, (local2 - arg1)) != 0) { + break label_4; + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, arg1) != 0) { + break label_5; + } + arg0 = local7; + label_6: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0), memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0) { + break label_4; + } + arg0 = (arg0 + 8); + arg1 = (arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + local2 = memory.readInt((int) (local10 + 56) < 0 ? (local10 + 56) : (local10 + 56) + 0); + arg1 = memory.readInt((int) (local10 + 52) < 0 ? (local10 + 52) : (local10 + 52) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, (local2 - arg1)) != 0) { + break label_4; + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, arg1) != 0) { + break label_7; + } + return local9; + } + arg0 = local5; + label_8: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0), memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0) { + break label_4; + } + arg0 = (arg0 + 8); + arg1 = (arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + return local9; + } + local9 = (local9 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local9) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + return -1; + } + + public static long[] call_135(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_135(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_136(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 51) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0) != 0 ? memory.readInt((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0) : local3)) != 0) { + break label_1; + } + memory.writeLong((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (long) memory.readLong((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) ((memory.readInt((int) (arg0 + 176) < 0 ? (arg0 + 176) : (arg0 + 176) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 172)) >> 2)); + local3 = (arg0 + 348); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local2 + 8)); + callArgs_0[2] = ((long) (arg1 + 40)); + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (local2 + 32)); + instance.getMachine().call(137, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + callArgs_1[0] = ((long) local3); + long[] callResult_1 = instance.getMachine().call(138, callArgs_1); + } + local4 = (arg1 + 36); + label_2: { + label_3: { + label_4: { + label_5: { + local3 = memory.readInt((int) (arg0 + 176) < 0 ? (arg0 + 176) : (arg0 + 176) + 0); + local5 = memory.readInt((int) (arg0 + 180) < 0 ? (arg0 + 180) : (arg0 + 180) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local5) != 0) { + break label_5; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 176, (int) (local3 + 4)); + break label_4; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 172); + local7 = ((local3 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_3; + } + label_6: { + label_7: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_7; + } + local9 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local8 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local9 = ((int) callResult_2[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local4); + local4 = (local9 + (local8 << 2)); + local8 = (local5 + 4); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local3) != 0) { + break label_8; + } + label_9: while (true) { + local5 = (local5 + -4); + local3 = (local3 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 172); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 180, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 176, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 172, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + } + label_10: { + label_11: { + local3 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local3 != 0) { + break label_11; + } + local3 = (arg0 + 32); + break label_10; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local3); + local3 = (local3 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local3 = (arg0 + 40); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 1)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_136(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_136(arg0, arg1, memory, instance); + return null; + } + + public static void func_137(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local4 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 44); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg1 + 8)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local4); + arg1 = (local4 + 8); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg2 < 0 ? arg2 : arg2 + 11), 0) != 0) { + break label_2; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + break label_1; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4)); + callArgs_1[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + callArgs_1[0] = ((long) arg1); + instance.getMachine().call(1647, callArgs_1); + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 8, (byte) (1)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeLong((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0, (long) memory.readLong((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0)); + memory.writeLong((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (long) memory.readLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + arg3 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 19); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg3, 0); + arg0 = (arg2 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 8) : arg1); + label_3: { + label_4: { + arg1 = (arg2 != 0 ? memory.readInt((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0) : (arg3 & 255)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 4) != 0) { + break label_4; + } + arg3 = arg1; + arg2 = arg1; + break label_3; + } + label_5: { + label_6: { + arg2 = (arg1 + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg2 & 4)) != 0) { + break label_6; + } + arg3 = arg1; + break label_5; + } + arg3 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) * 1540483477); + arg3 = ((((arg3 >>> 24) ^ arg3) * 1540483477) ^ (arg1 * 1540483477)); + arg0 = (arg0 + 4); + arg1 = arg2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 4) != 0) { + break label_3; + } + arg2 = arg1; + label_7: while (true) { + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) * 1540483477); + _snap_0 = arg1; + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) * 1540483477); + arg3 = ((((_snap_0 >>> 24) ^ _snap_0) * 1540483477) ^ (((((arg1 >>> 24) ^ arg1) * 1540483477) ^ (arg3 * 1540483477)) * 1540483477)); + arg0 = (arg0 + 8); + arg2 = (arg2 + -8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + label_8: { + label_9: { + label_10: { + label_11: { + switch((arg2 + -1)) { + case 0: + { + break label_9; + } + case 1: + { + break label_10; + } + case 2: + { + break label_11; + } + default: + { + break label_8; + } + } + } + arg3 = ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) << 16) ^ arg3); + } + arg3 = ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) << 8) ^ arg3); + } + arg3 = ((arg3 ^ ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) * 1540483477); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + arg0 = (((arg3 >>> 13) ^ arg3) * 1540483477); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) ((arg0 >>> 15) ^ arg0)); + return; + } + + public static long[] call_137(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_137(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_138(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (arg1 + 8); + local3 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 19) & 0xFF); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local5 = (local4 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) : local2); + label_1: { + label_2: { + local6 = (local4 != 0 ? memory.readInt((int) (arg1 + 12) < 0 ? (arg1 + 12) : (arg1 + 12) + 0) : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 4) != 0) { + break label_2; + } + local3 = local6; + local4 = local6; + break label_1; + } + label_3: { + label_4: { + local4 = (local6 + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local4 & 4)) != 0) { + break label_4; + } + local3 = local6; + break label_3; + } + local3 = (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) * 1540483477); + local3 = ((((local3 >>> 24) ^ local3) * 1540483477) ^ (local6 * 1540483477)); + local5 = (local5 + 4); + local6 = local4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 4) != 0) { + break label_1; + } + local4 = local6; + label_5: while (true) { + local6 = (memory.readInt((int) local5 < 0 ? local5 : local5 + 4) * 1540483477); + _snap_0 = local6; + local6 = (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) * 1540483477); + local3 = ((((_snap_0 >>> 24) ^ _snap_0) * 1540483477) ^ (((((local6 >>> 24) ^ local6) * 1540483477) ^ (local3 * 1540483477)) * 1540483477)); + local5 = (local5 + 8); + local4 = (local4 + -8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + label_6: { + label_7: { + label_8: { + label_9: { + switch((local4 + -1)) { + case 0: + { + break label_7; + } + case 1: + { + break label_8; + } + case 2: + { + break label_9; + } + default: + { + break label_6; + } + } + } + local3 = ((((int) memory.read((int) local5 < 0 ? local5 : local5 + 2) & 0xFF) << 16) ^ local3); + } + local3 = ((((int) memory.read((int) local5 < 0 ? local5 : local5 + 1) & 0xFF) << 8) ^ local3); + } + local3 = ((local3 ^ ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) * 1540483477); + } + local5 = (((local3 >>> 13) ^ local3) * 1540483477); + local5 = ((local5 >>> 15) ^ local5); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local5); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(165, callArgs_0); + local3 = ((int) callResult_0[0]); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + label_10: { + label_11: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 1) != 0) { + break label_11; + } + local5 = ((local4 + -1) & local5); + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local4) != 0) { + break label_10; + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local5, local4); + } + label_12: { + label_13: { + label_14: { + if (local3 != 0) { + break label_14; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local5 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local5 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local5 << 2)) + 0, (int) (arg0 + 8)); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_12; + } + local3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 1) != 0) { + break label_15; + } + local3 = (local3 & (local4 + -1)); + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0) { + break label_13; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local3, local4); + break label_13; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_12; + } + local3 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + label_16: { + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 1) != 0) { + break label_17; + } + local3 = (local3 & (local4 + -1)); + break label_16; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0) { + break label_16; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local3, local4); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local3) != 0) { + break label_12; + } + } + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) + 0, (int) arg1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 1)); + return arg1; + } + + public static long[] call_138(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_138(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_139(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 51) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0) != 0 ? memory.readInt((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0) : local3)) != 0) { + break label_1; + } + memory.writeLong((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (long) memory.readLong((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) ((memory.readInt((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 148)) >> 2)); + local3 = (arg0 + 368); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local2 + 8)); + callArgs_0[2] = ((long) (arg1 + 40)); + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (local2 + 32)); + instance.getMachine().call(137, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + callArgs_1[0] = ((long) local3); + long[] callResult_1 = instance.getMachine().call(138, callArgs_1); + } + local4 = (arg1 + 36); + label_2: { + label_3: { + label_4: { + label_5: { + local3 = memory.readInt((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0); + local5 = memory.readInt((int) (arg0 + 156) < 0 ? (arg0 + 156) : (arg0 + 156) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local5) != 0) { + break label_5; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 152, (int) (local3 + 4)); + break label_4; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 148); + local7 = ((local3 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_3; + } + label_6: { + label_7: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_7; + } + local9 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local8 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local9 = ((int) callResult_2[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local4); + local4 = (local9 + (local8 << 2)); + local8 = (local5 + 4); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local3) != 0) { + break label_8; + } + label_9: while (true) { + local5 = (local5 + -4); + local3 = (local3 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 148); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 156, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 152, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 148, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + } + label_10: { + label_11: { + local3 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local3 != 0) { + break label_11; + } + local3 = (arg0 + 32); + break label_10; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local3); + local3 = (local3 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local3 = (arg0 + 40); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 1)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_139(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_139(arg0, arg1, memory, instance); + return null; + } + + public static void func_140(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 36); + label_1: { + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 47) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0) != 0 ? memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0) : local4)) != 0) { + break label_1; + } + memory.writeLong((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (long) memory.readLong((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) ((memory.readInt((int) (arg0 + 68) < 0 ? (arg0 + 68) : (arg0 + 68) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 64)) >> 2)); + local4 = (arg0 + 208); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local2 + 8)); + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (local2 + 32)); + instance.getMachine().call(137, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(138, callArgs_1); + } + label_2: { + label_3: { + label_4: { + label_5: { + local4 = memory.readInt((int) (arg0 + 68) < 0 ? (arg0 + 68) : (arg0 + 68) + 0); + local5 = memory.readInt((int) (arg0 + 72) < 0 ? (arg0 + 72) : (arg0 + 72) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 68, (int) (local4 + 4)); + break label_4; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 64); + local7 = ((local4 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_3; + } + label_6: { + label_7: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_7; + } + local9 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local8 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local9 = ((int) callResult_2[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + local3 = (local9 + (local8 << 2)); + local8 = (local5 + 4); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_8; + } + label_9: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 64); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 68, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 64, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + label_10: { + label_11: { + local4 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local4 != 0) { + break label_11; + } + local4 = (arg0 + 32); + break label_10; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + local4 = (local4 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local4 = (arg0 + 40); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 1)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_140(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_140(arg0, arg1, memory, instance); + return null; + } + + public static void func_141(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (long) memory.readLong((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + local3 = (arg0 + 116); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) ((memory.readInt((int) local3 < 0 ? local3 : local3 + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 112)) >> 2)); + local4 = (arg0 + 268); + local5 = (arg1 + 36); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local2 + 8)); + callArgs_0[2] = ((long) local5); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (local2 + 32)); + instance.getMachine().call(137, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(138, callArgs_1); + label_1: { + label_2: { + label_3: { + label_4: { + local3 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local4 = memory.readInt((int) (arg0 + 120) < 0 ? (arg0 + 120) : (arg0 + 120) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local4) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 116, (int) (local3 + 4)); + break label_3; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 112); + local7 = ((local3 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + label_5: { + label_6: { + local4 = (local4 - local6); + local9 = (local4 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_6; + } + local9 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local8 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local9 = ((int) callResult_2[0]); + } + local4 = (local9 + (local7 << 2)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local5); + local5 = (local9 + (local8 << 2)); + local8 = (local4 + 4); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local3) != 0) { + break label_7; + } + label_8: while (true) { + local4 = (local4 + -4); + local3 = (local3 + -4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 112); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 120, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 116, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 112, (int) local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + } + label_9: { + label_10: { + local3 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local3 != 0) { + break label_10; + } + local3 = (arg0 + 32); + break label_9; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local3); + local3 = (local3 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local3 = (arg0 + 40); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 1)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_141(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_141(arg0, arg1, memory, instance); + return null; + } + + public static void func_142(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 36); + label_1: { + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 47) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0) != 0 ? memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0) : local4)) != 0) { + break label_1; + } + memory.writeLong((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (long) memory.readLong((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) ((memory.readInt((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 76)) >> 2)); + local4 = (arg0 + 228); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local2 + 8)); + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (local2 + 32)); + instance.getMachine().call(137, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(138, callArgs_1); + } + label_2: { + label_3: { + label_4: { + label_5: { + local4 = memory.readInt((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0); + local5 = memory.readInt((int) (arg0 + 84) < 0 ? (arg0 + 84) : (arg0 + 84) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 80, (int) (local4 + 4)); + break label_4; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 76); + local7 = ((local4 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_3; + } + label_6: { + label_7: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_7; + } + local9 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local8 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local9 = ((int) callResult_2[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + local3 = (local9 + (local8 << 2)); + local8 = (local5 + 4); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_8; + } + label_9: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 76); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 84, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 80, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + label_10: { + label_11: { + local4 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local4 != 0) { + break label_11; + } + local4 = (arg0 + 32); + break label_10; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + local4 = (local4 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local4 = (arg0 + 40); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 1)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_142(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_142(arg0, arg1, memory, instance); + return null; + } + + public static void func_143(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local4 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 35) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0) != 0 ? memory.readInt((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0) : local4)) != 0) { + break label_1; + } + memory.writeLong((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (long) memory.readLong((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) ((memory.readInt((int) (arg0 + 128) < 0 ? (arg0 + 128) : (arg0 + 128) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 124)) >> 2)); + local4 = (arg0 + 288); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local2 + 8)); + callArgs_0[2] = ((long) (local3 + 24)); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (local2 + 32)); + instance.getMachine().call(137, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(138, callArgs_1); + } + label_2: { + label_3: { + label_4: { + label_5: { + local4 = memory.readInt((int) (arg0 + 128) < 0 ? (arg0 + 128) : (arg0 + 128) + 0); + local5 = memory.readInt((int) (arg0 + 132) < 0 ? (arg0 + 132) : (arg0 + 132) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 128, (int) (local4 + 4)); + break label_4; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 124); + local7 = ((local4 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_3; + } + label_6: { + label_7: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_7; + } + local9 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local8 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local9 = ((int) callResult_2[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + local3 = (local9 + (local8 << 2)); + local8 = (local5 + 4); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_8; + } + label_9: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 124); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 132, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 128, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 124, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + label_10: { + label_11: { + local4 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local4 != 0) { + break label_11; + } + local4 = (arg0 + 32); + break label_10; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + local4 = (local4 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local4 = (arg0 + 40); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 1)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_143(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_143(arg0, arg1, memory, instance); + return null; + } + + public static void func_144(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 36); + label_1: { + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 47) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0) != 0 ? memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0) : local4)) != 0) { + break label_1; + } + memory.writeLong((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (long) memory.readLong((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) ((memory.readInt((int) (arg0 + 92) < 0 ? (arg0 + 92) : (arg0 + 92) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 88)) >> 2)); + local4 = (arg0 + 248); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local2 + 8)); + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (local2 + 32)); + instance.getMachine().call(137, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(138, callArgs_1); + } + label_2: { + label_3: { + label_4: { + label_5: { + local4 = memory.readInt((int) (arg0 + 92) < 0 ? (arg0 + 92) : (arg0 + 92) + 0); + local5 = memory.readInt((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 92, (int) (local4 + 4)); + break label_4; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 88); + local7 = ((local4 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_3; + } + label_6: { + label_7: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_7; + } + local9 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local8 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local9 = ((int) callResult_2[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + local3 = (local9 + (local8 << 2)); + local8 = (local5 + 4); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_8; + } + label_9: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 88); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 96, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 92, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 88, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + label_10: { + label_11: { + local4 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local4 != 0) { + break label_11; + } + local4 = (arg0 + 32); + break label_10; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + local4 = (local4 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local4 = (arg0 + 40); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 1)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_144(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_144(arg0, arg1, memory, instance); + return null; + } + + public static void func_145(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + local3 = -1; + local4 = 0; + local5 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + switch(memory.readInt((int) local6 < 0 ? local6 : local6 + 28)) { + case 0: + { + break label_9; + } + case 1: + { + break label_8; + } + case 2: + { + break label_7; + } + case 3: + { + break label_6; + } + case 4: + { + break label_5; + } + default: + { + break label_3; + } + } + } + local5 = (local6 + 32); + local4 = memory.readInt((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 76); + local3 = ((local4 - local7) >> 2); + label_10: { + label_11: { + local8 = memory.readInt((int) (arg0 + 84) < 0 ? (arg0 + 84) : (arg0 + 84) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local8) != 0) { + break label_11; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 80, (int) (local4 + 4)); + break label_10; + } + local9 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 1073741824) != 0) { + break label_2; + } + label_12: { + label_13: { + local8 = (local8 - local7); + local10 = (local8 >>> 1); + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local10, local9) != 0 ? local10 : local9) : 1073741823); + if (local9 != 0) { + break label_13; + } + local10 = 0; + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 1073741824) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local9 << 2)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local10 = ((int) callResult_0[0]); + } + local8 = (local10 + (local3 << 2)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local5); + local9 = (local10 + (local9 << 2)); + local10 = (local8 + 4); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local4) != 0) { + break label_14; + } + label_15: while (true) { + local8 = (local8 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_15; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 76); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 84, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 80, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_10; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_1); + } + local4 = (arg0 + 228); + local8 = (arg0 + 48); + break label_4; + } + local5 = (local6 + 32); + local4 = memory.readInt((int) (arg0 + 140) < 0 ? (arg0 + 140) : (arg0 + 140) + 0); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 136); + local3 = ((local4 - local7) >> 2); + label_16: { + label_17: { + local8 = memory.readInt((int) (arg0 + 144) < 0 ? (arg0 + 144) : (arg0 + 144) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local8) != 0) { + break label_17; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 140, (int) (local4 + 4)); + break label_16; + } + local9 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 1073741824) != 0) { + break label_2; + } + label_18: { + label_19: { + local8 = (local8 - local7); + local10 = (local8 >>> 1); + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local10, local9) != 0 ? local10 : local9) : 1073741823); + if (local9 != 0) { + break label_19; + } + local10 = 0; + break label_18; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 1073741824) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local9 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local10 = ((int) callResult_2[0]); + } + local8 = (local10 + (local3 << 2)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local5); + local9 = (local10 + (local9 << 2)); + local10 = (local8 + 4); + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local4) != 0) { + break label_20; + } + label_21: while (true) { + local8 = (local8 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_21; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 136); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 144, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 140, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 136, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_16; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + local4 = (arg0 + 308); + local8 = (arg0 + 52); + break label_4; + } + local5 = (local6 + 32); + local4 = memory.readInt((int) (arg0 + 164) < 0 ? (arg0 + 164) : (arg0 + 164) + 0); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 160); + local3 = ((local4 - local7) >> 2); + label_22: { + label_23: { + local8 = memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local8) != 0) { + break label_23; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 164, (int) (local4 + 4)); + break label_22; + } + local9 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 1073741824) != 0) { + break label_2; + } + label_24: { + label_25: { + local8 = (local8 - local7); + local10 = (local8 >>> 1); + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local10, local9) != 0 ? local10 : local9) : 1073741823); + if (local9 != 0) { + break label_25; + } + local10 = 0; + break label_24; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 1073741824) != 0) { + break label_1; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) (local9 << 2)); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local10 = ((int) callResult_4[0]); + } + local8 = (local10 + (local3 << 2)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local5); + local9 = (local10 + (local9 << 2)); + local10 = (local8 + 4); + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local4) != 0) { + break label_26; + } + label_27: while (true) { + local8 = (local8 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_27; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 160); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 168, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 164, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 160, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_22; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_5); + } + local4 = (arg0 + 328); + local8 = (arg0 + 56); + break label_4; + } + local5 = (local6 + 32); + local4 = memory.readInt((int) (arg0 + 92) < 0 ? (arg0 + 92) : (arg0 + 92) + 0); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 88); + local3 = ((local4 - local7) >> 2); + label_28: { + label_29: { + local8 = memory.readInt((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local8) != 0) { + break label_29; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 92, (int) (local4 + 4)); + break label_28; + } + local9 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 1073741824) != 0) { + break label_2; + } + label_30: { + label_31: { + local8 = (local8 - local7); + local10 = (local8 >>> 1); + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local10, local9) != 0 ? local10 : local9) : 1073741823); + if (local9 != 0) { + break label_31; + } + local10 = 0; + break label_30; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 1073741824) != 0) { + break label_1; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) (local9 << 2)); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + local10 = ((int) callResult_6[0]); + } + local8 = (local10 + (local3 << 2)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local5); + local9 = (local10 + (local9 << 2)); + local10 = (local8 + 4); + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local4) != 0) { + break label_32; + } + label_33: while (true) { + local8 = (local8 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_33; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 88); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 96, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 92, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 88, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_28; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_7); + } + local4 = (arg0 + 248); + local8 = (arg0 + 60); + break label_4; + } + local5 = (local6 + 32); + local4 = memory.readInt((int) (arg0 + 68) < 0 ? (arg0 + 68) : (arg0 + 68) + 0); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 64); + local3 = ((local4 - local7) >> 2); + label_34: { + label_35: { + local8 = memory.readInt((int) (arg0 + 72) < 0 ? (arg0 + 72) : (arg0 + 72) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local8) != 0) { + break label_35; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 68, (int) (local4 + 4)); + break label_34; + } + local9 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 1073741824) != 0) { + break label_2; + } + label_36: { + label_37: { + local8 = (local8 - local7); + local10 = (local8 >>> 1); + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local10, local9) != 0 ? local10 : local9) : 1073741823); + if (local9 != 0) { + break label_37; + } + local10 = 0; + break label_36; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 1073741824) != 0) { + break label_1; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) (local9 << 2)); + long[] callResult_8 = instance.getMachine().call(1776, callArgs_8); + local10 = ((int) callResult_8[0]); + } + local8 = (local10 + (local3 << 2)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local5); + local9 = (local10 + (local9 << 2)); + local10 = (local8 + 4); + label_38: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local4) != 0) { + break label_38; + } + label_39: while (true) { + local8 = (local8 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_39; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 64); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 68, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 64, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_34; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_9); + } + local4 = (arg0 + 208); + local8 = (arg0 + 44); + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 1)); + } + label_40: { + local8 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 11) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local8), 0) != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 4) : local8)) != 0) { + break label_40; + } + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + memory.writeLong((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (long) memory.readLong((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + long[] callArgs_10 = new long[4]; + callArgs_10[3] = ((long) (local2 + 8)); + callArgs_10[2] = ((long) local5); + callArgs_10[1] = ((long) local4); + callArgs_10[0] = ((long) (local2 + 32)); + instance.getMachine().call(146, callArgs_10); + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + callArgs_11[0] = ((long) local4); + long[] callResult_11 = instance.getMachine().call(138, callArgs_11); + } + label_41: { + label_42: { + local4 = memory.readInt((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 108) < 0 ? (arg0 + 108) : (arg0 + 108) + 0), local4) != 0) { + break label_42; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 104, (int) (local4 + 4)); + break label_41; + } + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100); + local5 = (local4 - local8); + local9 = (local5 >> 2); + local3 = (local9 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 1073741824) != 0) { + break label_2; + } + label_43: { + label_44: { + local7 = (local5 >>> 1); + local3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, local3) != 0 ? local7 : local3) : 1073741823); + if (local3 != 0) { + break label_44; + } + local7 = 0; + break label_43; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 1073741824) != 0) { + break label_1; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) (local3 << 2)); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + local7 = ((int) callResult_12[0]); + } + local5 = (local7 + (local9 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + local3 = (local7 + (local3 << 2)); + local6 = (local5 + 4); + label_45: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local4) != 0) { + break label_45; + } + label_46: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_46; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 108, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 104, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 100, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_41; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_13); + } + label_47: { + label_48: { + local4 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local4 != 0) { + break label_48; + } + local4 = (arg0 + 32); + break label_47; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + local4 = (local4 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local4 = (arg0 + 40); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 1)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_145(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_145(arg0, arg1, memory, instance); + return null; + } + + public static void func_146(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local4 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 44); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg1 + 8)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local4); + arg1 = (local4 + 8); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg2 < 0 ? arg2 : arg2 + 11), 0) != 0) { + break label_2; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + break label_1; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4)); + callArgs_1[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + callArgs_1[0] = ((long) arg1); + instance.getMachine().call(1647, callArgs_1); + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 8, (byte) (1)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeLong((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0, (long) memory.readLong((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0)); + memory.writeLong((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (long) memory.readLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + arg3 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 19); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg3, 0); + arg0 = (arg2 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 8) : arg1); + label_3: { + label_4: { + arg1 = (arg2 != 0 ? memory.readInt((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0) : (arg3 & 255)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 4) != 0) { + break label_4; + } + arg3 = arg1; + arg2 = arg1; + break label_3; + } + label_5: { + label_6: { + arg2 = (arg1 + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg2 & 4)) != 0) { + break label_6; + } + arg3 = arg1; + break label_5; + } + arg3 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) * 1540483477); + arg3 = ((((arg3 >>> 24) ^ arg3) * 1540483477) ^ (arg1 * 1540483477)); + arg0 = (arg0 + 4); + arg1 = arg2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 4) != 0) { + break label_3; + } + arg2 = arg1; + label_7: while (true) { + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) * 1540483477); + _snap_0 = arg1; + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) * 1540483477); + arg3 = ((((_snap_0 >>> 24) ^ _snap_0) * 1540483477) ^ (((((arg1 >>> 24) ^ arg1) * 1540483477) ^ (arg3 * 1540483477)) * 1540483477)); + arg0 = (arg0 + 8); + arg2 = (arg2 + -8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + label_8: { + label_9: { + label_10: { + label_11: { + switch((arg2 + -1)) { + case 0: + { + break label_9; + } + case 1: + { + break label_10; + } + case 2: + { + break label_11; + } + default: + { + break label_8; + } + } + } + arg3 = ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) << 16) ^ arg3); + } + arg3 = ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) << 8) ^ arg3); + } + arg3 = ((arg3 ^ ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) * 1540483477); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + arg0 = (((arg3 >>> 13) ^ arg3) * 1540483477); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) ((arg0 >>> 15) ^ arg0)); + return; + } + + public static long[] call_146(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_146(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_147(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 40); + label_1: { + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 51) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0) != 0 ? memory.readInt((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0) : local4)) != 0) { + break label_1; + } + memory.writeLong((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (long) memory.readLong((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) ((memory.readInt((int) (arg0 + 164) < 0 ? (arg0 + 164) : (arg0 + 164) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 160)) >> 2)); + local4 = (arg0 + 328); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local2 + 8)); + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (local2 + 32)); + instance.getMachine().call(137, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(138, callArgs_1); + } + label_2: { + label_3: { + label_4: { + label_5: { + local4 = memory.readInt((int) (arg0 + 164) < 0 ? (arg0 + 164) : (arg0 + 164) + 0); + local5 = memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 164, (int) (local4 + 4)); + break label_4; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 160); + local7 = ((local4 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_3; + } + label_6: { + label_7: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_7; + } + local9 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local8 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local9 = ((int) callResult_2[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + local3 = (local9 + (local8 << 2)); + local8 = (local5 + 4); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_8; + } + label_9: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 160); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 168, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 164, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 160, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + label_10: { + label_11: { + local4 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local4 != 0) { + break label_11; + } + local4 = (arg0 + 32); + break label_10; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + local4 = (local4 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local4 = (arg0 + 40); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 1)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_147(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_147(arg0, arg1, memory, instance); + return null; + } + + public static void func_148(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (arg1 + 36); + label_1: { + label_2: { + label_3: { + label_4: { + local3 = memory.readInt((int) (arg0 + 188) < 0 ? (arg0 + 188) : (arg0 + 188) + 0); + local4 = memory.readInt((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local4) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 188, (int) (local3 + 4)); + break label_3; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 184); + local6 = ((local3 - local5) >> 2); + local7 = (local6 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 1073741824) != 0) { + break label_2; + } + label_5: { + label_6: { + local4 = (local4 - local5); + local8 = (local4 >>> 1); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local7) != 0 ? local8 : local7) : 1073741823); + if (local7 != 0) { + break label_6; + } + local8 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 1073741824) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local7 << 2)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local8 = ((int) callResult_0[0]); + } + local4 = (local8 + (local6 << 2)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local2); + local2 = (local8 + (local7 << 2)); + local7 = (local4 + 4); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local3) != 0) { + break label_7; + } + label_8: while (true) { + local4 = (local4 + -4); + local3 = (local3 + -4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 184); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 192, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 188, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 184, (int) local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + label_9: { + label_10: { + local3 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local3 != 0) { + break label_10; + } + local3 = (arg0 + 32); + break label_9; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local3); + local3 = (local3 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local3 = (arg0 + 40); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 1)); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_148(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_148(arg0, arg1, memory, instance); + return null; + } + + public static void func_149(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 40); + label_1: { + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 51) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0) != 0 ? memory.readInt((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0) : local4)) != 0) { + break label_1; + } + memory.writeLong((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (long) memory.readLong((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) ((memory.readInt((int) (arg0 + 140) < 0 ? (arg0 + 140) : (arg0 + 140) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 136)) >> 2)); + local4 = (arg0 + 308); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local2 + 8)); + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (local2 + 32)); + instance.getMachine().call(137, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(138, callArgs_1); + } + label_2: { + label_3: { + label_4: { + label_5: { + local4 = memory.readInt((int) (arg0 + 140) < 0 ? (arg0 + 140) : (arg0 + 140) + 0); + local5 = memory.readInt((int) (arg0 + 144) < 0 ? (arg0 + 144) : (arg0 + 144) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 140, (int) (local4 + 4)); + break label_4; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 136); + local7 = ((local4 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_3; + } + label_6: { + label_7: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_7; + } + local9 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local8 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local9 = ((int) callResult_2[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + local3 = (local9 + (local8 << 2)); + local8 = (local5 + 4); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_8; + } + label_9: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 136); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 144, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 140, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 136, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + label_10: { + label_11: { + local4 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (local4 != 0) { + break label_11; + } + local4 = (arg0 + 32); + break label_10; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + local4 = (local4 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg1); + local4 = (arg0 + 40); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 1)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_149(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_149(arg0, arg1, memory, instance); + return null; + } + + public static void func_150(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + switch(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32)) { + case 0: + { + break label_12; + } + case 1: + { + break label_11; + } + case 2: + { + break label_10; + } + case 3: + { + break label_9; + } + case 4: + { + break label_8; + } + case 5: + { + break label_7; + } + case 6: + { + break label_6; + } + case 7: + { + break label_5; + } + case 8: + { + break label_4; + } + case 9: + { + break label_3; + } + case 10: + { + break label_2; + } + default: + { + break label_1; + } + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(142, callArgs_0); + return; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(144, callArgs_1); + return; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(145, callArgs_2); + return; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(141, callArgs_3); + return; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(143, callArgs_4); + return; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(149, callArgs_5); + return; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(139, callArgs_6); + return; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(147, callArgs_7); + return; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(136, callArgs_8); + return; + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) arg1); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(148, callArgs_9); + return; + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) arg1); + callArgs_10[0] = ((long) arg0); + instance.getMachine().call(140, callArgs_10); + return; + } + int ciTableIdx_11 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_11 = instance.table(0).requiredRef(ciTableIdx_11); + com.dylibso.chicory.runtime.Instance ciRefInstance_11 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_11), instance); + if (!ciRefInstance_11.type(ciRefInstance_11.functionType(ciFuncId_11)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg1); + ciRefInstance_11.getMachine().call(ciFuncId_11, callArgs_11); + return; + } + + public static long[] call_150(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_150(arg0, arg1, memory, instance); + return null; + } + + public static void func_151(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + label_1: { + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + local3 = (arg1 + 4); + label_2: while (true) { + local4 = local3; + local5 = 0; + label_3: { + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4), local6) != 0) { + break label_3; + } + local5 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + local4 = (local5 + 8); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local5); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (local2 + -1)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 4, (long) 0L); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(150, callArgs_0); + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + return; + } + + public static long[] call_151(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_151(arg0, arg1, memory, instance); + return null; + } + + public static void func_152(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + local3 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_1; + } + local3 = (local3 + -12); + label_2: while (true) { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local3 + 11) < 0 ? (local3 + 11) : (local3 + 11) + 0), -1) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3); + local3 = (local3 + -12); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + local3 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) local4); + label_4: { + label_5: { + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local3), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, arg0) != 0) { + break label_5; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg0 - local5)); + callArgs_1[0] = ((long) arg2); + instance.getMachine().call(153, callArgs_1); + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local5, arg0) != 0) { + break label_4; + } + label_6: { + arg0 = (local3 + (arg0 * 12)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, local4) != 0) { + break label_6; + } + local3 = (local4 + -12); + label_7: while (true) { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local3 + 11) < 0 ? (local3 + 11) : (local3 + 11) + 0), -1) != 0) { + break label_8; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_2); + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg0, local3); + local3 = (local3 + -12); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) arg0); + } + label_9: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_9; + } + label_10: while (true) { + label_11: { + local5 = (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + (memory.readInt((int) (local3 + 40) < 0 ? (local3 + 40) : (local3 + 40) + 0) * 12)); + local4 = (local3 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local5) != 0) { + break label_11; + } + arg1 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 19) & 0xFF); + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1); + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 11), 0) != 0) { + break label_12; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg0, 0) != 0) { + break label_13; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + break label_11; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0)); + callArgs_3[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 8)); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = instance.getMachine().call(1659, callArgs_3); + break label_11; + } + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg0, 0); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (arg0 != 0 ? memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0) : arg1)); + callArgs_4[1] = ((long) (arg0 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 8) : local4)); + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1658, callArgs_4); + } + local3 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + return; + } + + public static long[] call_152(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_152(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_153(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 12), arg1) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + local2 = ((arg1 * 12) + -12); + local2 = ((local2 - com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local2, 12)) + 12); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + local3 = (((int) callResult_0[0]) + local2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + return; + } + label_3: { + label_4: { + label_5: { + label_6: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 12); + local6 = (local5 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 357913942) != 0) { + break label_6; + } + local7 = 0; + label_7: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local4), 12); + local8 = (local2 << 1); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 357913942) != 0) { + break label_5; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local6 * 12)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + } + local2 = (local7 + (local5 * 12)); + arg1 = ((arg1 * 12) + -12); + arg1 = ((arg1 - com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg1, 12)) + 12); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + local8 = ((int) callResult_2[0]); + local5 = (local8 + arg1); + local7 = (local7 + (local6 * 12)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_4; + } + label_8: while (true) { + local2 = (local2 + -12); + local3 = (local3 + -12); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + arg1 = (local3 + 8); + memory.writeI32((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local5); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg1) != 0) { + break label_3; + } + local2 = (arg1 + -12); + label_9: while (true) { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + 11) < 0 ? (local2 + 11) : (local2 + 11) + 0), -1) != 0) { + break label_10; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_3); + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2); + local2 = (local2 + -12); + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break label_3; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local8); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_11; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_6); + } + return; + } + + public static long[] call_153(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_153(arg0, arg1, memory, instance); + return null; + } + + public static int func_154(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) -1); + memory.writeLong((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) 0L); + return arg0; + } + + public static long[] call_154(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_154(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_155(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) 0); + return arg0; + } + + public static long[] call_155(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_155(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_156(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) 1); + label_1: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 2147483632) != 0) { + break label_1; + } + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 10) != 0) { + break label_3; + } + arg1 = (arg0 + 24); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 35, (byte) (arg2)); + break label_2; + } + local4 = ((arg2 | 15) + 1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0, (int) (local4 | -2147483648)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg1); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) arg2); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg1); + long[] callResult_1 = instance.getMachine().call(1891, callArgs_1); + memory.writeByte((int) (((int) callResult_1[0]) + arg2) < 0 ? (((int) callResult_1[0]) + arg2) : (((int) callResult_1[0]) + arg2) + 0, (byte) (0)); + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_156(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_156(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_157(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) -1); + memory.writeLong((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) 0L); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(158, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_157(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_157(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_158(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + local3 = (arg1 + 24); + label_1: { + label_2: { + label_3: { + if (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 20) != 0) { + break label_3; + } + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_4; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) 0); + break label_2; + } + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 35) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + local4 = (local5 != 0 ? memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0) : local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 2147483632) != 0) { + break label_1; + } + local3 = (local5 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24) : local3); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 10) != 0) { + break label_6; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 11, (byte) (local4)); + arg1 = local2; + break label_5; + } + local5 = ((local4 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) (local5 | -2147483648)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local4); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local4) < 0 ? (((int) callResult_2[0]) + local4) : (((int) callResult_2[0]) + local4) + 0, (byte) (0)); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_7; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_3); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) 1); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 24, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + } + instance.global(0).setValue(((long) (local2 + 16))); + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_158(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_158(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_159(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) -1); + memory.writeLong((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) 0L); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(160, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_159(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_159(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_160(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + local3 = (arg1 + 24); + label_1: { + label_2: { + label_3: { + if (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 20) != 0) { + break label_3; + } + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_4; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) 0); + break label_2; + } + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 35) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + local4 = (local5 != 0 ? memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0) : local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 2147483632) != 0) { + break label_1; + } + local3 = (local5 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24) : local3); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 10) != 0) { + break label_6; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 11, (byte) (local4)); + arg1 = local2; + break label_5; + } + local5 = ((local4 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) (local5 | -2147483648)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local4); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local4) < 0 ? (((int) callResult_2[0]) + local4) : (((int) callResult_2[0]) + local4) + 0, (byte) (0)); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_7; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_3); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) 1); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 24, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + } + instance.global(0).setValue(((long) (local2 + 16))); + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_160(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_160(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_161(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) 0); + return; + } + + public static long[] call_161(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_161(arg0, arg1, memory, instance); + return null; + } + + public static int func_162(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_0); + } + return arg0; + } + + public static long[] call_162(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_162(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_163(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + switch(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) { + case 0: + { + break label_4; + } + case 1: + { + break label_3; + } + case 2: + { + break label_2; + } + default: + { + break label_1; + } + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg0 + 16)); + callArgs_0[0] = ((long) (arg1 + 308)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + arg1 = ((int) callResult_0[0]); + local2 = (arg1 != 0 ? 2 : (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-16, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 52)) << 1)); + break label_1; + } + local2 = 1; + break label_1; + } + local2 = 3; + } + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-16, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 52)) != 0) { + break label_6; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 72); + arg0 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, arg1) != 0) { + break label_5; + } + label_7: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(36, memory.readInt((int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 32) < 0 ? (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 32) : (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 32) + 0)) != 0) { + break label_6; + } + arg1 = (arg1 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, arg1) != 0) { + break label_5; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + } + local2 = (local2 | 4); + } + return local2; + } + + public static long[] call_163(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_163(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_164(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg0 + 16)); + callArgs_0[0] = ((long) (arg1 + 328)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + return (((int) callResult_0[0]) != 0 ? (local2 | 2) : local2); + } + + public static long[] call_164(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_164(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_165(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + float local3 = 0.0f; + float local4 = 0.0f; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local3 = memory.readFloat((int) arg0 < 0 ? arg0 : arg0 + 16); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 1)); + label_1: { + label_2: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(com.dylibso.chicory.runtime.OpcodeImpl.F32_LT((local3 * com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U(local5)), local4)) != 0) { + break label_1; + } + } + local6 = ((local5 << 1) | (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (local5 & (local5 + -1))))); + label_3: { + label_4: { + local3 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CEIL((local4 / local3)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.F32_LT(local3, 4.2949673E9f) & com.dylibso.chicory.runtime.OpcodeImpl.F32_GE(local3, 0.0f))) != 0) { + break label_4; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_TRUNC_F32_U(local3); + break label_3; + } + local7 = 0; + } + local8 = 2; + label_5: { + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local7) != 0 ? local6 : local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6) != 0) { + break label_5; + } + label_6: { + if ((local6 & (local6 + -1)) != 0) { + break label_6; + } + local8 = local6; + break label_5; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1572, callArgs_0); + local8 = ((int) callResult_0[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local5) != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, local5) != 0) { + break label_7; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 3); + label_9: { + label_10: { + local3 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CEIL((com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)) / memory.readFloat((int) arg0 < 0 ? arg0 : arg0 + 16))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.F32_LT(local3, 4.2949673E9f) & com.dylibso.chicory.runtime.OpcodeImpl.F32_GE(local3, 0.0f))) != 0) { + break label_10; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_TRUNC_F32_U(local3); + break label_9; + } + local6 = 0; + } + label_11: { + label_12: { + if (local7 != 0) { + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local5), 1) != 0) { + break label_12; + } + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 2) != 0 ? local6 : (1 << (32 - com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ((local6 + -1))))); + break label_11; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1572, callArgs_1); + local6 = ((int) callResult_1[0]); + } + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, local5) != 0) { + break label_7; + } + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local8); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(166, callArgs_2); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + label_13: { + label_14: { + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 1) != 0) { + break label_14; + } + local9 = ((local5 + -1) & arg1); + break label_13; + } + local9 = arg1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, arg1) != 0) { + break label_13; + } + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg1, local5); + } + label_15: { + local6 = memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local9 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local9 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local9 << 2)) + 0); + if (local6 != 0) { + break label_15; + } + return 0; + } + arg0 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 11) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0); + local10 = (local7 != 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : arg2); + local11 = (local7 != 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) : arg0); + label_16: { + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 2) != 0) { + break label_17; + } + arg0 = 0; + label_18: while (true) { + local12 = arg0; + local13 = local6; + local6 = memory.readInt((int) local13 < 0 ? local13 : local13 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_16; + } + arg0 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + arg2 = arg0; + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, local5) != 0) { + break label_19; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg0, local5); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, arg2) != 0) { + break label_16; + } + local7 = 0; + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg0) != 0) { + break label_20; + } + local7 = 0; + arg2 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 19) & 0xFF); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0) != 0 ? memory.readInt((int) (local6 + 12) < 0 ? (local6 + 12) : (local6 + 12) + 0) : arg2)) != 0) { + break label_20; + } + arg0 = (local6 + 8); + label_21: { + label_22: { + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0); + if (local7 != 0) { + break label_22; + } + if (local8 != 0) { + break label_21; + } + local7 = 1; + break label_20; + } + label_23: { + if (local11 != 0) { + break label_23; + } + local7 = 1; + break label_20; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local11); + callArgs_3[1] = ((long) local10); + callArgs_3[0] = ((long) (local7 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : arg0)); + long[] callResult_3 = instance.getMachine().call(1889, callArgs_3); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_3[0])); + break label_20; + } + local14 = (arg2 + -1); + arg2 = local10; + label_24: while (true) { + local8 = local14; + local14 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + local15 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local15, local14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local15, local14) != 0) { + break label_20; + } + local14 = (local8 + -1); + arg2 = (arg2 + 1); + arg0 = (arg0 + 1); + if (local8 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_24; + } + break; + } + } + arg0 = (local12 | local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, (local12 & (local7 ^ 1))) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break label_16; + } + } + local12 = (local5 + -1); + arg0 = 0; + label_25: while (true) { + local5 = arg0; + local13 = local6; + local6 = memory.readInt((int) local13 < 0 ? local13 : local13 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_16; + } + arg0 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, (arg0 & local12)) != 0) { + break label_16; + } + local7 = 0; + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg0) != 0) { + break label_26; + } + local7 = 0; + arg2 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 19) & 0xFF); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0) != 0 ? memory.readInt((int) (local6 + 12) < 0 ? (local6 + 12) : (local6 + 12) + 0) : arg2)) != 0) { + break label_26; + } + arg0 = (local6 + 8); + label_27: { + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0); + if (local7 != 0) { + break label_27; + } + label_28: { + if (local8 != 0) { + break label_28; + } + local7 = 1; + break label_26; + } + local14 = (arg2 + -1); + arg2 = local10; + label_29: while (true) { + local8 = local14; + local14 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + local15 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local15, local14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local15, local14) != 0) { + break label_26; + } + local14 = (local8 + -1); + arg2 = (arg2 + 1); + arg0 = (arg0 + 1); + if (local8 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_29; + } + break label_26; + } + } + label_30: { + if (local11 != 0) { + break label_30; + } + local7 = 1; + break label_26; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local11); + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local7 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : arg0)); + long[] callResult_4 = instance.getMachine().call(1889, callArgs_4); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_4[0])); + } + arg0 = (local5 | local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local5 & (local7 ^ 1))) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_25; + } + break; + } + } + return local13; + } + + public static long[] call_165(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_165(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_166(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg1 << 2)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_4; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + local2 = (arg1 & 3); + local4 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 4) != 0) { + break label_5; + } + local5 = (arg1 & -4); + local3 = 8; + local4 = 0; + label_6: while (true) { + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) + 0, (int) 0); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) + 0, (int) 0); + local3 = (local3 + 16); + local4 = (local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_7; + } + local3 = (local4 << 2); + label_8: while (true) { + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 0, (int) 0); + local3 = (local3 + 4); + local2 = (local2 + -1); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + local3 = (arg0 + 8); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + label_9: { + label_10: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 1) != 0) { + break label_10; + } + local7 = (local7 & (arg1 + -1)); + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, arg1) != 0) { + break label_9; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local7, arg1); + } + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local7 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local7 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local7 << 2)) + 0, (int) local3); + local5 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + local8 = (arg1 + -1); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 1); + label_11: while (true) { + local3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + label_12: { + label_13: { + if (local9 != 0) { + break label_13; + } + local3 = (local3 & local8); + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, arg1) != 0) { + break label_12; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local3, arg1); + } + label_14: { + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local3) != 0) { + break label_15; + } + local6 = local5; + break label_14; + } + label_16: { + label_17: { + label_18: { + label_19: { + local10 = (local3 << 2); + local2 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) local2 < 0 ? local2 : local2 + 0)) != 0) { + break label_19; + } + label_20: { + local3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (local3 != 0) { + break label_20; + } + local11 = local5; + break label_17; + } + local2 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 19) & 0xFF); + local12 = (local2 & 255); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2); + local13 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local2, 0) != 0 ? memory.readInt((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0) : local12); + local14 = (local5 + 8); + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local2, -1) != 0) { + break label_21; + } + local2 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 19) & 0xFF); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0); + local2 = (local4 != 0 ? memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0) : local2); + label_22: { + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local13) != 0) { + break label_23; + } + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local13) != 0) { + break label_24; + } + local11 = local5; + break label_16; + } + local15 = memory.readInt((int) local14 < 0 ? local14 : local14 + 0); + local11 = local5; + break label_22; + } + local11 = local5; + if (local2 != 0) { + break label_16; + } + label_25: while (true) { + local11 = local3; + local3 = memory.readInt((int) local11 < 0 ? local11 : local11 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + local2 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 19) & 0xFF); + if ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0) != 0 ? memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0) : local2) != 0) { + break label_16; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_25; + } + } + label_26: while (true) { + label_27: { + local2 = local3; + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local13); + callArgs_2[1] = ((long) ((local4 & 1) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 8) : (local2 + 8))); + callArgs_2[0] = ((long) local15); + long[] callResult_2 = instance.getMachine().call(1889, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_2[0])) != 0) { + break label_27; + } + local3 = local2; + break label_16; + } + label_28: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_28; + } + local11 = local2; + local2 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 19) & 0xFF); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((local4 != 0 ? memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0) : local2), local13) != 0) { + break label_16; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_26; + } + break; + } + local11 = local2; + break label_17; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_18; + } + local11 = local5; + label_29: while (true) { + label_30: { + local15 = local3; + local3 = ((int) memory.read((int) local15 < 0 ? local15 : local15 + 19) & 0xFF); + _snap_0 = local3; + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local3 != 0 ? memory.readInt((int) (local15 + 12) < 0 ? (local15 + 12) : (local15 + 12) + 0) : _snap_0), local13) != 0) { + break label_30; + } + local3 = local15; + break label_16; + } + local3 = (local3 != 0 ? memory.readInt((int) local15 < 0 ? local15 : local15 + 8) : (local15 + 8)); + local2 = local14; + local4 = local12; + label_31: while (true) { + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF), ((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF)) != 0) { + break label_32; + } + local3 = local15; + break label_16; + } + local3 = (local3 + 1); + local2 = (local2 + 1); + local4 = (local4 + -1); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_31; + } + break; + } + local11 = local15; + local3 = memory.readInt((int) local15 < 0 ? local15 : local15 + 0); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_29; + } + break; + } + local11 = local15; + break label_17; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local6); + local6 = local5; + local7 = local3; + break label_14; + } + local11 = local5; + local2 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 19) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0) != 0 ? memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0) : local2), local13) != 0) { + break label_16; + } + label_33: while (true) { + local11 = local3; + local3 = memory.readInt((int) local11 < 0 ? local11 : local11 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + local2 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 19) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0) != 0 ? memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0) : local2), local13) != 0) { + break label_16; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_33; + } + } + local3 = 0; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) memory.readInt((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) + 0) + 0)); + memory.writeI32((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local10) + 0) + 0, (int) local5); + } + local5 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break label_1; + } + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 0); + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_34; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_4); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) 0); + } + return; + } + + public static long[] call_166(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_166(arg0, arg1, memory, instance); + return null; + } + + public static int func_167(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + local1 = 0; + label_1: while (true) { + local1 = (local1 + 1); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 127); + arg0 = (arg0 >>> 7); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + break; + } + return local1; + } + + public static long[] call_167(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_167(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_168(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 15, (byte) ((arg2 >>> 28))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 11, (byte) ((arg2 | 128))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 14, (byte) (((arg2 >>> 21) | 128))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 13, (byte) (((arg2 >>> 14) | 128))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 12, (byte) (((arg2 >>> 7) | 128))); + long[] callArgs_0 = new long[6]; + callArgs_0[5] = ((long) 0); + callArgs_0[4] = ((long) arg3); + callArgs_0[3] = ((long) 5); + callArgs_0[2] = ((long) (local4 + 11)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(221, callArgs_0); + instance.global(0).setValue(((long) (local4 + 16))); + return 5; + } + + public static long[] call_168(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_168(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_169(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 128) != 0) { + break label_2; + } + local4 = 0; + local5 = arg1; + break label_1; + } + local4 = 0; + label_3: while (true) { + memory.writeByte((int) ((local3 + 11) + local4) < 0 ? ((local3 + 11) + local4) : ((local3 + 11) + local4) + 0, (byte) ((arg1 | 128))); + local4 = (local4 + 1); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 16383); + local5 = (arg1 >>> 7); + arg1 = local5; + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + memory.writeByte((int) ((local3 + 11) + local4) < 0 ? ((local3 + 11) + local4) : ((local3 + 11) + local4) + 0, (byte) (local5)); + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) (local4 + 1)); + callArgs_0[1] = ((long) (local3 + 11)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(224, callArgs_0); + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_169(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_169(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_170(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 15, (byte) ((arg1 >>> 28))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 11, (byte) ((arg1 | 128))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 14, (byte) (((arg1 >>> 21) | 128))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 13, (byte) (((arg1 >>> 14) | 128))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 12, (byte) (((arg1 >>> 7) | 128))); + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) 5); + callArgs_0[1] = ((long) (local3 + 11)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(224, callArgs_0); + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_170(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_170(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_171(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 128) != 0) { + break label_2; + } + local5 = 0; + local6 = arg2; + break label_1; + } + local5 = 0; + label_3: while (true) { + memory.writeByte((int) ((local4 + 11) + local5) < 0 ? ((local4 + 11) + local5) : ((local4 + 11) + local5) + 0, (byte) ((arg2 | 128))); + local5 = (local5 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 16383); + local6 = (arg2 >>> 7); + arg2 = local6; + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + memory.writeByte((int) ((local4 + 11) + local5) < 0 ? ((local4 + 11) + local5) : ((local4 + 11) + local5) + 0, (byte) (local6)); + arg2 = (local5 + 1); + long[] callArgs_0 = new long[6]; + callArgs_0[5] = ((long) 0); + callArgs_0[4] = ((long) arg3); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) (local4 + 11)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(221, callArgs_0); + instance.global(0).setValue(((long) (local4 + 16))); + return arg2; + } + + public static long[] call_171(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_171(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_172(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = 0; + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 128) != 0) { + break label_2; + } + local5 = arg2; + local6 = 0; + break label_1; + } + local6 = 0; + label_3: while (true) { + memory.writeByte((int) ((local3 + 11) + local6) < 0 ? ((local3 + 11) + local6) : ((local3 + 11) + local6) + 0, (byte) ((arg2 | 128))); + local6 = (local6 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 16383); + local5 = (arg2 >>> 7); + arg2 = local5; + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + memory.writeByte((int) ((local3 + 11) + local6) < 0 ? ((local3 + 11) + local6) : ((local3 + 11) + local6) + 0, (byte) (local5)); + label_4: { + arg2 = (local6 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((arg1 - arg0), arg2) != 0) { + break label_4; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) (local3 + 11)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1890, callArgs_0); + local4 = arg2; + } + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_172(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_172(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_173(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = 0; + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 64) != 0) { + break label_2; + } + local5 = arg1; + break label_1; + } + label_4: { + local6 = (arg1 >> 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg1 & 64)) != 0) { + break label_4; + } + local5 = arg1; + break label_1; + } + local4 = 0; + label_5: while (true) { + memory.writeByte((int) ((local3 + 11) + local4) < 0 ? ((local3 + 11) + local4) : ((local3 + 11) + local4) + 0, (byte) ((arg1 | 128))); + local5 = local6; + local7 = (local5 & 64); + local4 = (local4 + 1); + arg1 = local5; + local6 = (local5 >> 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + arg1 = local5; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break label_1; + } + } + local4 = 0; + label_6: while (true) { + memory.writeByte((int) ((local3 + 11) + local4) < 0 ? ((local3 + 11) + local4) : ((local3 + 11) + local4) + 0, (byte) ((arg1 | 128))); + local4 = (local4 + 1); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 8191); + local5 = (arg1 >>> 7); + arg1 = local5; + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) ((local3 + 11) + local4) < 0 ? ((local3 + 11) + local4) : ((local3 + 11) + local4) + 0, (byte) ((local5 & 127))); + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) (local4 + 1)); + callArgs_0[1] = ((long) (local3 + 11)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(224, callArgs_0); + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_173(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_173(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_174(int arg0, long arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(arg1, 128L) != 0) { + break label_2; + } + local4 = 0; + local5 = arg1; + break label_1; + } + local4 = 0; + label_3: while (true) { + memory.writeByte((int) ((local3 + 6) + local4) < 0 ? ((local3 + 6) + local4) : ((local3 + 6) + local4) + 0, (byte) (((int) arg1 | 128))); + local4 = (local4 + 1); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg1, 16383L); + local5 = (arg1 >>> 7L); + arg1 = local5; + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + memory.writeByte((int) ((local3 + 6) + local4) < 0 ? ((local3 + 6) + local4) : ((local3 + 6) + local4) + 0, (byte) (int) (local5)); + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) (local4 + 1)); + callArgs_0[1] = ((long) (local3 + 6)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(224, callArgs_0); + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_174(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_174(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_175(int arg0, long arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + long local8 = 0L; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = (int) arg1; + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(arg1, 0L) != 0) { + break label_2; + } + local5 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(arg1, 64L) != 0) { + break label_1; + } + local5 = 0; + label_3: while (true) { + memory.writeByte((int) ((local3 + 6) + local5) < 0 ? ((local3 + 6) + local5) : ((local3 + 6) + local5) + 0, (byte) ((local4 | 128))); + local5 = (local5 + 1); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg1, 8191L); + arg1 = (arg1 >>> 7L); + local4 = (int) arg1; + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break label_1; + } + } + label_4: { + local7 = (arg1 >> 7L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(-1L, local7) != 0) { + break label_4; + } + local5 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(0L, (arg1 & 64L)) != 0) { + break label_1; + } + } + local5 = 0; + label_5: while (true) { + memory.writeByte((int) ((local3 + 6) + local5) < 0 ? ((local3 + 6) + local5) : ((local3 + 6) + local5) + 0, (byte) ((local4 | 128))); + local8 = (local7 & 64L); + local5 = (local5 + 1); + local4 = (int) local7; + arg1 = (local7 >> 7L); + local7 = arg1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(-1L, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + local7 = arg1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(local8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + memory.writeByte((int) ((local3 + 6) + local5) < 0 ? ((local3 + 6) + local5) : ((local3 + 6) + local5) + 0, (byte) ((local4 & 127))); + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) (local5 + 1)); + callArgs_0[1] = ((long) (local3 + 6)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(224, callArgs_0); + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_175(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_175(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_176(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 11, (byte) ((arg1 | 128))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 14, (byte) (((arg1 >>> 21) | 128))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 13, (byte) (((arg1 >>> 14) | 128))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 12, (byte) (((arg1 >>> 7) | 128))); + local4 = (arg1 >>> 28); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 15, (byte) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? (local4 | 112) : local4))); + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) 5); + callArgs_0[1] = ((long) (local3 + 11)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(224, callArgs_0); + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_176(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_176(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_177(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, arg1) != 0) { + break label_3; + } + local3 = (int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_3; + } + local4 = (local3 & 255); + local3 = 1; + break label_2; + } + label_4: { + local3 = (arg0 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_4; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_4; + } + local4 = (((local3 & 255) << 7) | (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127)); + local3 = 2; + break label_2; + } + label_5: { + local3 = (arg0 + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_5; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_5; + } + local4 = ((((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127) << 7) | (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127)) | ((local3 & 255) << 14)); + local3 = 3; + break label_2; + } + label_6: { + local3 = (arg0 + 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_6; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_6; + } + local4 = (((((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127) << 7) | (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127)) | ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127) << 14)) | ((local3 & 255) << 21)); + local3 = 4; + break label_2; + } + local4 = 0; + local3 = 0; + local5 = (arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, arg1) != 0) { + break label_2; + } + local4 = 0; + local3 = 0; + arg1 = (int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_2; + } + local3 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 15) != 0) { + break label_1; + } + local4 = ((((((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127) << 7) | (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127)) | ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127) << 14)) | ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127) << 21)) | ((arg1 & 255) << 28)); + local3 = 5; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + } + return local3; + } + + public static long[] call_177(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_177(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_178(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + int local5 = 0; + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, arg1) != 0) { + break label_3; + } + local3 = (int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_3; + } + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L); + local3 = 1; + break label_2; + } + label_4: { + local3 = (arg0 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_4; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_4; + } + local4 = (((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 7L) | ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L)); + local3 = 2; + break label_2; + } + label_5: { + local3 = (arg0 + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_5; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_5; + } + local4 = (((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 7L) | ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L)) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 14L)); + local3 = 3; + break label_2; + } + label_6: { + local3 = (arg0 + 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_6; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_6; + } + local4 = ((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 7L) | ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 14L)) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 21L)); + local3 = 4; + break label_2; + } + label_7: { + local3 = (arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_7; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_7; + } + local4 = (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 7L) | ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 14L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 21L)) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 28L)); + local3 = 5; + break label_2; + } + label_8: { + local3 = (arg0 + 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_8; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_8; + } + local4 = ((((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 7L) | ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 14L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 21L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) & 127L) << 28L)) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 35L)); + local3 = 6; + break label_2; + } + label_9: { + local3 = (arg0 + 6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_9; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_9; + } + local4 = (((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 5) & 0xFF) & 127L) << 35L) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 42L)) | (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 7L) | ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 14L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 21L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) & 127L) << 28L))); + local3 = 7; + break label_2; + } + label_10: { + local3 = (arg0 + 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_10; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_10; + } + local4 = ((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF) & 127L) << 42L) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 49L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 5) & 0xFF) & 127L) << 35L)) | (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 7L) | ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 14L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 21L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) & 127L) << 28L))); + local3 = 8; + break label_2; + } + label_11: { + local3 = (arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_11; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_11; + } + local4 = (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 7) & 0xFF) & 127L) << 49L) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 56L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF) & 127L) << 42L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 5) & 0xFF) & 127L) << 35L)) | (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 7L) | ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 14L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 21L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) & 127L) << 28L))); + local3 = 9; + break label_2; + } + local3 = 0; + local4 = 0L; + local5 = (arg0 + 9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, arg1) != 0) { + break label_2; + } + local3 = 0; + arg1 = (int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_2; + } + local3 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 1) != 0) { + break label_1; + } + local4 = ((((((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 8) & 0xFF) & 127)) << 56L) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg1) & 255L) << 63L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 7) & 0xFF) & 127L) << 49L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF) & 127L) << 42L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 5) & 0xFF) & 127L) << 35L)) | (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 7L) | ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 14L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 21L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) & 127L) << 28L))); + local3 = 10; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) local4); + } + return local3; + } + + public static long[] call_178(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_178(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_179(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, arg1) != 0) { + break label_3; + } + local3 = (int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_3; + } + arg0 = (((local3 & 255) << 25) >> 25); + local3 = 1; + break label_2; + } + label_4: { + local3 = (arg0 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_4; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_4; + } + arg0 = ((((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127) << 18) | ((local3 & 255) << 25)) >> 18); + local3 = 2; + break label_2; + } + label_5: { + local3 = (arg0 + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_5; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_5; + } + arg0 = (((((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127) << 11) | ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127) << 18)) | ((local3 & 255) << 25)) >> 11); + local3 = 3; + break label_2; + } + label_6: { + local3 = (arg0 + 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_6; + } + local4 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0) { + break label_6; + } + local3 = 4; + arg0 = ((((((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127) << 4) | ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127) << 11)) | ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127) << 18)) | ((local4 & 255) << 25)) >> 4); + break label_2; + } + local3 = 0; + local4 = (arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, arg1) != 0) { + break label_1; + } + local3 = 0; + arg1 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_1; + } + arg1 = (arg1 & 255); + local4 = ((arg1 & 8) >>> 3); + local5 = (arg1 & 240); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, (local4 & com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(112, local5))) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local4 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5))) != 0) { + break label_1; + } + arg0 = ((((((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127) << 7) | (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127)) | ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127) << 14)) | ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127) << 21)) | (arg1 << 28)); + local3 = 5; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg0); + } + return local3; + } + + public static long[] call_179(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_179(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_180(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + int local5 = 0; + int local6 = 0; + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, arg1) != 0) { + break label_3; + } + local3 = (int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_3; + } + local4 = (((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 57L) >> 57L); + local3 = 1; + break label_2; + } + label_4: { + local3 = (arg0 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_4; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_4; + } + local4 = (((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L) << 50L) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 57L)) >> 50L); + local3 = 2; + break label_2; + } + label_5: { + local3 = (arg0 + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_5; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_5; + } + local4 = ((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L) << 43L) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 50L)) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 57L)) >> 43L); + local3 = 3; + break label_2; + } + label_6: { + local3 = (arg0 + 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_6; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_6; + } + local4 = (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L) << 36L) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 43L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 50L)) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 57L)) >> 36L); + local3 = 4; + break label_2; + } + label_7: { + local3 = (arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_7; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_7; + } + local4 = ((((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L) << 29L) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 36L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 43L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 50L)) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 57L)) >> 29L); + local3 = 5; + break label_2; + } + label_8: { + local3 = (arg0 + 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_8; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_8; + } + local4 = (((((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L) << 22L) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 29L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 36L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 43L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) & 127L) << 50L)) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 57L)) >> 22L); + local3 = 6; + break label_2; + } + label_9: { + local3 = (arg0 + 6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_9; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_9; + } + local4 = ((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 5) & 0xFF) & 127L) << 50L) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 57L)) | (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L) << 15L) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 22L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 29L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 36L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) & 127L) << 43L))) >> 15L); + local3 = 7; + break label_2; + } + label_10: { + local3 = (arg0 + 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_10; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_10; + } + local4 = (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF) & 127L) << 50L) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 57L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 5) & 0xFF) & 127L) << 43L)) | (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L) << 8L) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 15L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 22L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 29L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) & 127L) << 36L))) >> 8L); + local3 = 8; + break label_2; + } + label_11: { + local3 = (arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_11; + } + local3 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_11; + } + local4 = ((((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 7) & 0xFF) & 127L) << 50L) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) & 255L) << 57L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF) & 127L) << 43L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 5) & 0xFF) & 127L) << 36L)) | (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 8L) | (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) << 1)) & 254L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 15L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 22L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) & 127L) << 29L))) >> 1L); + local3 = 9; + break label_2; + } + local3 = 0; + local5 = (arg0 + 9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, arg1) != 0) { + break label_1; + } + local3 = 0; + arg1 = (int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_1; + } + local5 = (arg1 & 255); + local6 = (local5 & 254); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, (local5 & com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(126, local6))) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((local5 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6)) & 1)) != 0) { + break label_1; + } + local4 = ((((((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 8) & 0xFF) & 127)) << 56L) | ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg1) & 255L) << 63L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 7) & 0xFF) & 127L) << 49L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF) & 127L) << 42L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 5) & 0xFF) & 127L) << 35L)) | (((((((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 127L) << 7L) | ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 127L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & 127L) << 14L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & 127L) << 21L)) | (((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) & 127L) << 28L))); + local3 = 10; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) local4); + } + return local3; + } + + public static long[] call_180(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_180(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_181(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg1); + local2 = (arg0 + 12); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + memory.writeShort((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (short) (0)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(189, callArgs_0); + label_1: { + arg1 = memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + local2 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local2) != 0) { + break label_1; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (arg1 + 8)); + return arg0; + } + label_2: { + label_3: { + local3 = memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0); + local4 = ((arg1 - local3) >> 3); + local5 = (local4 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 536870912) != 0) { + break label_3; + } + local2 = (local2 - local3); + local6 = (local2 >>> 2); + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local5) != 0 ? local6 : local5) : 536870911); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 536870912) != 0) { + break label_2; + } + local5 = (local2 << 3); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local6 = ((int) callResult_1[0]); + local2 = (local6 + (local4 << 3)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + local5 = (local6 + local5); + local4 = (local2 + 8); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg1) != 0) { + break label_4; + } + label_5: while (true) { + local2 = (local2 + -8); + arg1 = (arg1 + -8); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_6; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_2); + } + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_181(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_181(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_182(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + int local9 = 0; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0); + local6 = memory.readInt((int) (arg1 + 12) < 0 ? (arg1 + 12) : (arg1 + 12) + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) 0L); + local7 = 1; + label_1: { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local4 + 40)); + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(183, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + label_2: { + label_3: { + local8 = memory.readLong((int) local4 < 0 ? local4 : local4 + 40); + local7 = (int) (local8 >>> 32L); + arg1 = (int) local8; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local7 - arg1), arg2) != 0) { + break label_3; + } + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 12, (int) 0); + arg2 = 1; + break label_2; + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local5 - local6), arg2) != 0) { + break label_4; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 + local6), 2); + } + local5 = (local7 - arg2); + local9 = (arg2 >>> 1); + local6 = (local6 + -1); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local9) != 0 ? ((arg1 - local9) + local6) : arg1); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local6) != 0 ? local5 : local6); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 12, (int) (local6 - arg1)); + local5 = (local6 + arg2); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local6) != 0) { + break label_7; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 29207); + callArgs_1[0] = ((long) arg3); + long[] callResult_1 = instance.getMachine().call(1662, callArgs_1); + arg1 = (local6 + 3); + if ((arg2 & 1) != 0) { + break label_6; + } + local7 = (local5 + -3); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg2 & 1)) != 0) { + break label_5; + } + } + local7 = local5; + break label_2; + } + local7 = (local5 + -3); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) 0L); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local8 = ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local7) << 32L) | com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg1)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local8); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) local8); + local7 = 1; + label_8: { + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 24)); + callArgs_2[1] = ((long) (local4 + 8)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(190, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_8; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 28)); + callArgs_3[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 24)); + callArgs_3[0] = ((long) arg3); + long[] callResult_3 = instance.getMachine().call(184, callArgs_3); + label_9: { + if ((arg2 & 1) != 0) { + break label_9; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 29207); + callArgs_4[0] = ((long) arg3); + long[] callResult_4 = instance.getMachine().call(1662, callArgs_4); + } + local7 = 0; + } + arg1 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) arg1); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local4 + 48))); + return local7; + } + + public static long[] call_182(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_182(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_183(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(((memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0) - local4) >> 3), arg1) != 0) { + break label_4; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) (local4 + (arg1 << 3)) < 0 ? (local4 + (arg1 << 3)) : (local4 + (arg1 << 3)) + 0)); + local4 = 0; + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 65536); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 65536); + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) ((int) callResult_0[0])); + long[] callResult_1 = instance.getMachine().call(1892, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) 0); + label_5: { + label_6: while (true) { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 21) & 0xFF)) != 0) { + break label_7; + } + local4 = 1; + break label_5; + } + local4 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 12)); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + long[] callResult_2 = instance.getMachine().call(187, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_5; + } + label_8: { + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 65536); + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + long[] callResult_3 = instance.getMachine().call(188, callArgs_3); + local6 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 65535) != 0) { + break label_8; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 21, (byte) (1)); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 1) != 0) { + break label_9; + } + local7 = (local5 + local6); + local8 = local5; + label_10: while (true) { + label_11: { + local4 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(10, local4) != 0) { + break label_11; + } + local9 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 20) & 0xFF); + local10 = ((memory.readInt((int) local3 < 0 ? local3 : local3 + 12) + local8) - (local5 + local9)); + label_12: { + label_13: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local11) != 0) { + break label_13; + } + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local10); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local11); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local4 + 8)); + break label_12; + } + local12 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local13 = ((local4 - local12) >> 3); + local14 = (local13 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local14, 536870912) != 0) { + break label_2; + } + local11 = (local11 - local12); + local15 = (local11 >>> 2); + local11 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local11, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local15, local14) != 0 ? local15 : local14) : 536870911); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local11, 536870912) != 0) { + break label_1; + } + local14 = (local11 << 3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local14); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local15 = ((int) callResult_4[0]); + local11 = (local15 + (local13 << 3)); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 4, (int) local10); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + local14 = (local15 + local14); + local15 = (local11 + 8); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local12, local4) != 0) { + break label_14; + } + label_15: while (true) { + local11 = (local11 + -8); + local4 = (local4 + -8); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local12, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_15; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local14); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local15); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_12; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local12); + instance.getMachine().call(1777, callArgs_5); + local9 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 20) & 0xFF); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) ((local10 + local9) + 1)); + local4 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 0) & 0xFF); + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 20, (byte) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(13, (local4 & 255)))); + local8 = (local8 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, local7) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 21) & 0xFF)) != 0) { + break label_16; + } + local8 = (memory.readInt((int) local3 < 0 ? local3 : local3 + 12) + local6); + label_17: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local11) != 0) { + break label_17; + } + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local11); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local4 + 8)); + break label_16; + } + local12 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local7 = ((local4 - local12) >> 3); + local10 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local10, 536870912) != 0) { + break label_2; + } + local11 = (local11 - local12); + local9 = (local11 >>> 2); + local11 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local11, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local10) != 0 ? local9 : local10) : 536870911); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local11, 536870912) != 0) { + break label_1; + } + local10 = (local11 << 3); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local10); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + local9 = ((int) callResult_6[0]); + local11 = (local9 + (local7 << 3)); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 4, (int) local8); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + local8 = (local9 + local10); + local10 = (local11 + 8); + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local12, local4) != 0) { + break label_18; + } + label_19: while (true) { + local11 = (local11 + -8); + local4 = (local4 + -8); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local12, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_19; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_16; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local12); + instance.getMachine().call(1777, callArgs_7); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local4) >> 3), arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) (local4 + (arg1 << 3)) < 0 ? (local4 + (arg1 << 3)) : (local4 + (arg1 << 3)) + 0)); + local4 = 0; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_183(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_183(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_184(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_2; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11) & 0xFF); + _snap_0 = local5; + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local5), 0); + local6 = (local5 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : _snap_0); + local7 = (arg2 - arg1); + label_3: { + label_4: { + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local9 = (local5 != 0 ? local8 : arg0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, arg1) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U((local9 + local6), arg1) != 0) { + break label_3; + } + } + label_5: { + label_6: { + local5 = (local5 != 0 ? ((local4 & 2147483647) + -1) : 10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((local5 - local6), local7) != 0) { + break label_6; + } + local5 = (local4 >>> 24); + break label_5; + } + long[] callArgs_0 = new long[7]; + callArgs_0[6] = ((long) 0); + callArgs_0[5] = ((long) 0); + callArgs_0[4] = ((long) local6); + callArgs_0[3] = ((long) local6); + callArgs_0[2] = ((long) ((local6 + local7) - local5)); + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1643, callArgs_0); + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11) & 0xFF); + } + local9 = ((arg1 ^ -1) + arg2); + local5 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local5), 0) != 0 ? local8 : arg0) + local6); + label_7: { + local4 = (local7 & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_7; + } + label_8: while (true) { + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF))); + arg1 = (arg1 + 1); + local5 = (local5 + 1); + local4 = (local4 + -1); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, 7) != 0) { + break label_9; + } + label_10: while (true) { + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF))); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 1, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 1) & 0xFF))); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 2, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 2) & 0xFF))); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 3, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 3) & 0xFF))); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 4, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 4) & 0xFF))); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 5, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 5) & 0xFF))); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 6, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 6) & 0xFF))); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 7, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 7) & 0xFF))); + local5 = (local5 + 8); + arg1 = (arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (0)); + arg1 = (local6 + local7); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11), -1) != 0) { + break label_11; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (arg1)); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 2147483632) != 0) { + break label_1; + } + label_12: { + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, 10) != 0) { + break label_13; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 11, (byte) (local7)); + local5 = local3; + break label_12; + } + local4 = ((local7 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) (local4 | -2147483648)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local7); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local7); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1890, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local7) < 0 ? (((int) callResult_2[0]) + local7) : (((int) callResult_2[0]) + local7) + 0, (byte) (0)); + arg1 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 11) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local5 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 4) : arg1)); + callArgs_3[1] = ((long) (local5 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : local3)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1652, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), -1) != 0) { + break label_2; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_4); + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_184(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_184(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_185(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg1); + return arg0; + } + + public static long[] call_185(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_185(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_186(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 12); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + return local1; + } + + public static long[] call_186(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_186(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_187(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + return 0; + } + + public static long[] call_187(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_187(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_188(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + label_1: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local4 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local3); + arg2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, arg2) != 0 ? local4 : arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3)); + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1890, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + arg2)); + } + return arg2; + } + + public static long[] call_188(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_188(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_189(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = 1; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4), arg1) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + local2 = 0; + } + return local2; + } + + public static long[] call_189(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_189(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_190(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0 ? local3 : local4); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, arg1) != 0 ? local3 : arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_1; + } + label_2: { + label_3: { + arg1 = (local4 - local3); + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local5 = (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) - local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg1, local5) != 0) { + break label_3; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 - local5)); + callArgs_0[0] = ((long) arg2); + instance.getMachine().call(191, callArgs_0); + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local5) != 0) { + break label_2; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) (local4 + arg1)); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1890, callArgs_1); + } + return 0; + } + + public static long[] call_190(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_190(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_191(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((local2 - local3), arg1) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + local3 = (((int) callResult_0[0]) + arg1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + return; + } + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = (local3 - local4); + local6 = (local5 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local6, -1) != 0) { + break label_3; + } + local7 = 0; + label_4: { + local2 = (local2 - local4); + local8 = (local2 << 1); + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6) : 2147483647); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_4; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + } + local6 = (local7 + local2); + local2 = (local7 + local5); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + local9 = ((int) callResult_2[0]); + local8 = (local9 + arg1); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_6; + } + local7 = local9; + break label_5; + } + local9 = ((local4 ^ -1) + local3); + label_7: { + arg1 = (local5 & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_7; + } + label_8: while (true) { + local2 = (local2 + -1); + local3 = (local3 + -1); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 0, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF))); + arg1 = (arg1 + -1); + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, 3) != 0) { + break label_9; + } + local2 = (local2 + -4); + label_10: while (true) { + memory.writeByte((int) (local2 + 3) < 0 ? (local2 + 3) : (local2 + 3) + 0, (byte) (((int) memory.read((int) (local3 + -1) < 0 ? (local3 + -1) : (local3 + -1) + 0) & 0xFF))); + memory.writeByte((int) (local2 + 2) < 0 ? (local2 + 2) : (local2 + 2) + 0, (byte) (((int) memory.read((int) (local3 + -2) < 0 ? (local3 + -2) : (local3 + -2) + 0) & 0xFF))); + memory.writeByte((int) (local2 + 1) < 0 ? (local2 + 1) : (local2 + 1) + 0, (byte) (((int) memory.read((int) (local3 + -3) < 0 ? (local3 + -3) : (local3 + -3) + 0) & 0xFF))); + local3 = (local3 + -4); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 0, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF))); + local2 = (local2 + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_11; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_191(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_191(arg0, arg1, memory, instance); + return null; + } + + public static void func_192(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + label_1: { + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 541) != 0) { + break label_1; + } + arg1 = (arg1 << 6); + memory.writeLong((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0, (long) memory.readLong((int) (arg1 + 62456) < 0 ? (arg1 + 62456) : (arg1 + 62456) + 0)); + memory.writeLong((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0, (long) memory.readLong((int) (arg1 + 62448) < 0 ? (arg1 + 62448) : (arg1 + 62448) + 0)); + memory.writeLong((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (long) memory.readLong((int) (arg1 + 62440) < 0 ? (arg1 + 62440) : (arg1 + 62440) + 0)); + memory.writeLong((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0, (long) memory.readLong((int) (arg1 + 62432) < 0 ? (arg1 + 62432) : (arg1 + 62432) + 0)); + memory.writeLong((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0, (long) memory.readLong((int) (arg1 + 62424) < 0 ? (arg1 + 62424) : (arg1 + 62424) + 0)); + memory.writeLong((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (long) memory.readLong((int) (arg1 + 62416) < 0 ? (arg1 + 62416) : (arg1 + 62416) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 62408) < 0 ? (arg1 + 62408) : (arg1 + 62408) + 0)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) (arg1 + 62400) < 0 ? (arg1 + 62400) : (arg1 + 62400) + 0)); + return; + } + local2 = (arg0 + 56); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 97144)); + local3 = (arg0 + 48); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 97136)); + memory.writeLong((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 97128)); + memory.writeLong((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 97120)); + memory.writeLong((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 97112)); + memory.writeLong((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 97104)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 97096)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 97088)); + arg1 = (0 - arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (arg1 & 130815)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 52, (int) (arg1 & 255)); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) ((arg1 >>> 9))); + return; + } + + public static long[] call_192(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_192(arg0, arg1, memory, instance); + return null; + } + + public static long func_193(int arg0, long arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(-1L, arg1) != 0) { + break label_1; + } + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + arg1 = memory.readLong((int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, 542) != 0 ? ((arg0 << 6) + 62440) : 97128) < 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, 542) != 0 ? ((arg0 << 6) + 62440) : 97128) : (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, 542) != 0 ? ((arg0 << 6) + 62440) : 97128) + 0); + } + return arg1; + } + + public static long[] call_193(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + long result = Wat2WasmMachine.func_193(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = result; + return out; + } + + public static int func_194(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[3]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = 0; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + int _d0 = func_194__h0(iL, memory, instance); + if (_d0 == 1) + break label_2; + if (_d0 == 2) + break label_3; + if (_d0 == 3) + break label_1; + if (_d0 == 4) + break label_5; + if (_d0 == 5) + break label_4; + if (_d0 == 6) + break label_7; + if (_d0 == 7) + break label_6; + if (_d0 == 8) + return iL[0]; + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 5) & 0xFF)); + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 4) & 0xFF)); + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 17) & 0xFF)); + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 9) & 0xFF)); + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 10) & 0xFF)); + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 6) & 0xFF)); + } + iL[2] = 1; + } + return iL[2]; + } + + public static long[] call_194(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_194(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_195(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = 16; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + switch((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + -240)) { + case 0: + { + break label_1; + } + case 1: + { + break label_1; + } + case 2: + { + break label_1; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_2; + } + case 6: + { + break label_5; + } + case 7: + { + break label_5; + } + case 8: + { + break label_4; + } + case 9: + { + break label_4; + } + case 10: + { + break label_5; + } + case 11: + { + break label_5; + } + case 12: + { + break label_4; + } + case 13: + { + break label_4; + } + case 14: + { + break label_3; + } + case 15: + { + break label_3; + } + case 16: + { + break label_3; + } + case 17: + { + break label_3; + } + case 18: + { + break label_3; + } + case 19: + { + break label_3; + } + case 20: + { + break label_3; + } + case 21: + { + break label_3; + } + case 22: + { + break label_3; + } + case 23: + { + break label_3; + } + case 24: + { + break label_3; + } + case 25: + { + break label_3; + } + case 26: + { + break label_3; + } + case 27: + { + break label_3; + } + case 28: + { + break label_3; + } + case 29: + { + break label_3; + } + case 30: + { + break label_3; + } + case 31: + { + break label_3; + } + case 32: + { + break label_3; + } + case 33: + { + break label_3; + } + case 34: + { + break label_3; + } + case 35: + { + break label_3; + } + case 36: + { + break label_3; + } + case 37: + { + break label_3; + } + case 38: + { + break label_3; + } + case 39: + { + break label_3; + } + case 40: + { + break label_3; + } + case 41: + { + break label_3; + } + case 42: + { + break label_3; + } + case 43: + { + break label_3; + } + case 44: + { + break label_3; + } + case 45: + { + break label_3; + } + case 46: + { + break label_3; + } + case 47: + { + break label_3; + } + case 48: + { + break label_3; + } + case 49: + { + break label_3; + } + case 50: + { + break label_3; + } + case 51: + { + break label_3; + } + case 52: + { + break label_3; + } + case 53: + { + break label_3; + } + case 54: + { + break label_3; + } + case 55: + { + break label_3; + } + case 56: + { + break label_3; + } + case 57: + { + break label_3; + } + case 58: + { + break label_3; + } + case 59: + { + break label_3; + } + case 60: + { + break label_3; + } + case 61: + { + break label_3; + } + case 62: + { + break label_3; + } + case 63: + { + break label_1; + } + case 64: + { + break label_2; + } + case 65: + { + break label_5; + } + case 66: + { + break label_4; + } + case 67: + { + break label_1; + } + case 68: + { + break label_2; + } + case 69: + { + break label_5; + } + case 70: + { + break label_4; + } + default: + { + break label_3; + } + } + } + return 4; + } + return 2; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local1 = 8; + } + return local1; + } + + public static long[] call_195(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_195(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_196(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 541) != 0) { + break label_5; + } + local3 = (arg1 << 6); + local4 = ((int) memory.read((int) (local3 + 62448) < 0 ? (local3 + 62448) : (local3 + 62448) + 0) & 0xFF); + if (local4 != 0) { + break label_4; + } + local3 = memory.readInt((int) (local3 + 62452) < 0 ? (local3 + 62452) : (local3 + 62452) + 0); + break label_2; + } + local3 = (0 - arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local3 & 130560)) != 0) { + break label_3; + } + local4 = (local3 >>> 9); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local4)); + local3 = (local3 + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + local4 = (local2 + 16); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 541) != 0) { + break label_7; + } + arg1 = memory.readInt((int) ((arg1 << 6) + 62452) < 0 ? ((arg1 << 6) + 62452) : ((arg1 << 6) + 62452) + 0); + break label_6; + } + arg1 = ((0 - arg1) & 255); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) (local2 + 11)); + long[] callResult_1 = instance.getMachine().call(172, callArgs_1); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) ((local2 + 11) + ((int) callResult_1[0]))); + callArgs_2[2] = ((long) (local2 + 11)); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(197, callArgs_2); + break label_1; + } + local3 = (local3 & 255); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 1); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg1 = ((int) callResult_3[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg1); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (local3)); + arg1 = (arg1 + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + } + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_196(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_196(arg0, arg1, memory, instance); + return null; + } + + public static int func_197(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + label_1: { + label_2: { + local4 = (arg3 - arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 1) != 0) { + break label_2; + } + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local4, (local5 - local6)) != 0) { + break label_3; + } + label_4: { + label_5: { + local7 = (local6 - arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local4, local7) != 0) { + break label_5; + } + local8 = local6; + local9 = arg3; + break label_4; + } + local8 = local6; + label_6: { + local9 = (arg2 + local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg3, local9) != 0) { + break label_6; + } + local5 = local9; + local8 = local6; + label_7: while (true) { + memory.writeByte((int) local8 < 0 ? local8 : local8 + 0, (byte) (((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF))); + local8 = (local8 + 1); + local5 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg3, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 1) != 0) { + break label_2; + } + } + local7 = (local8 - (arg1 + local4)); + local5 = local8; + label_8: { + arg3 = (local8 - local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, local6) != 0) { + break label_8; + } + local5 = local8; + label_9: while (true) { + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (((int) memory.read((int) arg3 < 0 ? arg3 : arg3 + 0) & 0xFF))); + local5 = (local5 + 1); + arg3 = (arg3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local5); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local7); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local8 - local7)); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local9 - arg2)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) arg1); + long[] callResult_1 = instance.getMachine().call(1891, callArgs_1); + return ((int) callResult_1[0]); + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local8 = ((local6 - local7) + local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local8, -1) != 0) { + break label_1; + } + local10 = (arg1 - local7); + label_10: { + label_11: { + local5 = (local5 - local7); + local9 = (local5 << 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 2147483647); + if (local8 != 0) { + break label_11; + } + local5 = 0; + break label_10; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local8); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local5 = ((int) callResult_2[0]); + } + local9 = (local5 + local10); + local11 = local9; + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg3) != 0) { + break label_12; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local4); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) local9); + long[] callResult_3 = instance.getMachine().call(1890, callArgs_3); + local11 = (((int) callResult_3[0]) + local4); + } + arg2 = (local5 + local8); + label_13: { + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local7) != 0) { + break label_14; + } + arg3 = local9; + break label_13; + } + local4 = ((local7 ^ -1) + arg1); + label_15: { + label_16: { + local5 = (local10 & 3); + if (local5 != 0) { + break label_16; + } + arg3 = local9; + local5 = arg1; + break label_15; + } + local8 = 0; + local6 = (0 - local5); + label_17: while (true) { + local8 = (local8 + -1); + arg3 = (local8 + local9); + local5 = (local8 + arg1); + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 0, (byte) (((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_17; + } + break; + } + } + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 3) != 0) { + break label_18; + } + label_19: while (true) { + memory.writeByte((int) (arg3 + -1) < 0 ? (arg3 + -1) : (arg3 + -1) + 0, (byte) (((int) memory.read((int) (local5 + -1) < 0 ? (local5 + -1) : (local5 + -1) + 0) & 0xFF))); + memory.writeByte((int) (arg3 + -2) < 0 ? (arg3 + -2) : (arg3 + -2) + 0, (byte) (((int) memory.read((int) (local5 + -2) < 0 ? (local5 + -2) : (local5 + -2) + 0) & 0xFF))); + memory.writeByte((int) (arg3 + -3) < 0 ? (arg3 + -3) : (arg3 + -3) + 0, (byte) (((int) memory.read((int) (local5 + -3) < 0 ? (local5 + -3) : (local5 + -3) + 0) & 0xFF))); + arg3 = (arg3 + -4); + local5 = (local5 + -4); + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 0, (byte) (((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_19; + } + break; + } + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + local5 = (local6 - arg1); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) local11); + long[] callResult_4 = instance.getMachine().call(1891, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local8 + local5)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg3); + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_20; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_5); + } + arg1 = local9; + } + return arg1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_197(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_197(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_198(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 2147483632) != 0) { + break label_1; + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 10) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (local4)); + local5 = arg0; + break label_2; + } + local6 = ((local4 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local6 | -2147483648)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local4); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local4) < 0 ? (((int) callResult_2[0]) + local4) : (((int) callResult_2[0]) + local4) + 0, (byte) (0)); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg2); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local4 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 2147483632) != 0) { + break label_1; + } + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 10) != 0) { + break label_5; + } + arg1 = (arg0 + 12); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 23, (byte) (local4)); + break label_4; + } + local5 = ((local4 | 15) + 1); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg1 = ((int) callResult_4[0]); + memory.writeI32((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (int) (local5 | -2147483648)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg1); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) local4); + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local4); + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = instance.getMachine().call(1891, callArgs_5); + memory.writeByte((int) (((int) callResult_5[0]) + local4) < 0 ? (((int) callResult_5[0]) + local4) : (((int) callResult_5[0]) + local4) + 0, (byte) (0)); + memory.writeLong((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0, (long) 0L); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 24, (long) 0L); + memory.writeI32((int) (arg0 + 60) < 0 ? (arg0 + 60) : (arg0 + 60) + 0, (int) 41492); + memory.writeI32((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0, (int) 32); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 48, (int) arg0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) 41552); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) 33); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg0); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) local3); + callArgs_6[2] = ((long) 17407); + callArgs_6[1] = ((long) 11920); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(201, callArgs_6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) 41612); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) 34); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local3); + callArgs_7[2] = ((long) 12703); + callArgs_7[1] = ((long) 12777); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(201, callArgs_7); + instance.global(0).setValue(((long) (local3 + 16))); + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_198(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_198(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_199(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local3 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_3; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 27, (byte) (local3)); + local4 = (local2 + 16); + break label_2; + } + local5 = ((local3 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local4 = ((int) callResult_1[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) (local5 | -2147483648)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local3); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(1890, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local3) < 0 ? (((int) callResult_2[0]) + local3) : (((int) callResult_2[0]) + local3) + 0, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 27), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 16) : (local2 + 16))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 31693); + callArgs_3[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + long[] callResult_3 = instance.getMachine().call(1847, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 1); + instance.getMachine().call(1827, callArgs_4); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_199(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_199(arg0, arg1, memory, instance); + return null; + } + + public static void func_200(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(213, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 0); + instance.getMachine().call(1827, callArgs_1); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_200(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_200(arg0, memory, instance); + return null; + } + + public static void func_201(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local4)); + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local5 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 2147483632) != 0) { + break label_1; + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 10) != 0) { + break label_3; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 27, (byte) (local5)); + local6 = (local4 + 16); + break label_2; + } + local7 = ((local5 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local7); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local6 = ((int) callResult_1[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) (local7 | -2147483648)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) local6); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) local5); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local5); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(1890, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local5) < 0 ? (((int) callResult_2[0]) + local5) : (((int) callResult_2[0]) + local5) + 0, (byte) (0)); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg2); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local5 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 2147483632) != 0) { + break label_1; + } + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 10) != 0) { + break label_5; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 11, (byte) (local5)); + arg1 = local4; + break label_4; + } + local6 = ((local5 | 15) + 1); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg1 = ((int) callResult_4[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) (local6 | -2147483648)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local5); + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local5); + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = instance.getMachine().call(1890, callArgs_5); + memory.writeByte((int) (((int) callResult_5[0]) + local5) < 0 ? (((int) callResult_5[0]) + local5) : (((int) callResult_5[0]) + local5) + 0, (byte) (0)); + local6 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 8); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + local8 = ((long) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4) & 0xFFFFFFFFL); + label_6: { + arg2 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 12); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_6; + } + int ciTableIdx_6 = (int) (local5); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = ((int) callResult_6[0]); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) 16); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + local5 = ((int) callResult_7[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local6); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) ((local8 << 32L) | com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg1))); + memory.writeI32((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0, (int) arg2); + label_7: { + arg3 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_7; + } + int ciTableIdx_8 = (int) (arg3); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) ((int) callResult_8[0])); + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 32, (byte) (0)); + local7 = ((local4 + 32) | 4); + label_8: { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 27), 0) != 0) { + break label_9; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 16)); + memory.writeI32((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0, (int) memory.readInt((int) ((local4 + 16) + 8) < 0 ? ((local4 + 16) + 8) : ((local4 + 16) + 8) + 0)); + break label_8; + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 20)); + callArgs_9[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 16)); + callArgs_9[0] = ((long) local7); + instance.getMachine().call(1647, callArgs_9); + } + memory.writeLong((int) (local4 + 53) < 0 ? (local4 + 53) : (local4 + 53) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 48, (long) 0L); + local9 = (local4 + 64); + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), 0) != 0) { + break label_11; + } + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local9 + 8) < 0 ? (local9 + 8) : (local9 + 8) + 0, (int) memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + break label_10; + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 4)); + callArgs_10[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + callArgs_10[0] = ((long) local9); + instance.getMachine().call(1647, callArgs_10); + } + memory.writeI32((int) (local4 + 88) < 0 ? (local4 + 88) : (local4 + 88) + 0, (int) 41768); + memory.writeI32((int) (local4 + 84) < 0 ? (local4 + 84) : (local4 + 84) + 0, (int) 35); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 76, (int) local5); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) 16); + long[] callResult_11 = instance.getMachine().call(1776, callArgs_11); + arg3 = ((int) callResult_11[0]); + local8 = memory.readLong((int) local5 < 0 ? local5 : local5 + 0); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) local8); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 8, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 8)); + local10 = (local5 + 12); + local6 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 12, (int) local6); + label_12: { + local11 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_12; + } + int ciTableIdx_12 = (int) (local11); + int ciFuncId_12 = instance.table(0).requiredRef(ciTableIdx_12); + com.dylibso.chicory.runtime.Instance ciRefInstance_12 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_12), instance); + if (!ciRefInstance_12.type(ciRefInstance_12.functionType(ciFuncId_12)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) (int) local8); + long[] callResult_12 = ciRefInstance_12.getMachine().call(ciFuncId_12, callArgs_12); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) ((int) callResult_12[0])); + local6 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 76, (int) arg3); + label_13: { + arg3 = memory.readInt((int) (local6 + 4) < 0 ? (local6 + 4) : (local6 + 4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_13; + } + int ciTableIdx_13 = (int) (arg3); + int ciFuncId_13 = instance.table(0).requiredRef(ciTableIdx_13); + com.dylibso.chicory.runtime.Instance ciRefInstance_13 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_13), instance); + if (!ciRefInstance_13.type(ciRefInstance_13.functionType(ciFuncId_13)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + ciRefInstance_13.getMachine().call(ciFuncId_13, callArgs_13); + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_14); + label_14: { + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_14; + } + int ciTableIdx_15 = (int) (local5); + int ciFuncId_15 = instance.table(0).requiredRef(ciTableIdx_15); + com.dylibso.chicory.runtime.Instance ciRefInstance_15 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_15), instance); + if (!ciRefInstance_15.type(ciRefInstance_15.functionType(ciFuncId_15)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) arg1); + ciRefInstance_15.getMachine().call(ciFuncId_15, callArgs_15); + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_15; + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_16); + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 27), -1) != 0) { + break label_16; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 16)); + instance.getMachine().call(1777, callArgs_17); + } + label_17: { + label_18: { + local5 = memory.readInt((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0)) != 0) { + break label_18; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (((int) memory.read((int) local4 < 0 ? local4 : local4 + 32) & 0xFF))); + arg3 = (local5 + 4); + label_19: { + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 47), 0) != 0) { + break label_20; + } + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (int) memory.readInt((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0)); + break label_19; + } + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) memory.readInt((int) (local4 + 40) < 0 ? (local4 + 40) : (local4 + 40) + 0)); + callArgs_18[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 36)); + callArgs_18[0] = ((long) arg3); + instance.getMachine().call(1647, callArgs_18); + } + arg3 = (local5 + 16); + label_21: { + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 59), 0) != 0) { + break label_22; + } + arg1 = (local4 + 48); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_21; + } + long[] callArgs_19 = new long[3]; + callArgs_19[2] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 52)); + callArgs_19[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 48)); + callArgs_19[0] = ((long) arg3); + instance.getMachine().call(1647, callArgs_19); + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 28, (byte) (((int) memory.read((int) local4 < 0 ? local4 : local4 + 60) & 0xFF))); + arg3 = (local5 + 32); + label_23: { + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 75), 0) != 0) { + break label_24; + } + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) local9 < 0 ? local9 : local9 + 0)); + memory.writeI32((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (int) memory.readInt((int) (local9 + 8) < 0 ? (local9 + 8) : (local9 + 8) + 0)); + break label_23; + } + long[] callArgs_20 = new long[3]; + callArgs_20[2] = ((long) memory.readInt((int) (local4 + 68) < 0 ? (local4 + 68) : (local4 + 68) + 0)); + callArgs_20[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 64)); + callArgs_20[0] = ((long) arg3); + instance.getMachine().call(1647, callArgs_20); + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 44, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 76)); + memory.writeI32((int) (local5 + 52) < 0 ? (local5 + 52) : (local5 + 52) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 84)); + arg3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 88); + memory.writeI32((int) (local5 + 56) < 0 ? (local5 + 56) : (local5 + 56) + 0, (int) arg3); + label_25: { + arg3 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_25; + } + int ciTableIdx_21 = (int) (arg3); + int ciFuncId_21 = instance.table(0).requiredRef(ciTableIdx_21); + com.dylibso.chicory.runtime.Instance ciRefInstance_21 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_21), instance); + if (!ciRefInstance_21.type(ciRefInstance_21.functionType(ciFuncId_21)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 76)); + long[] callResult_21 = ciRefInstance_21.getMachine().call(ciFuncId_21, callArgs_21); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 44, (int) ((int) callResult_21[0])); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 28, (int) (local5 + 60)); + break label_17; + } + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) (local4 + 32)); + callArgs_22[0] = ((long) (arg0 + 24)); + instance.getMachine().call(204, callArgs_22); + } + label_26: { + local5 = memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 88) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 88) : memory.readInt((int) local4 < 0 ? local4 : local4 + 88) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_26; + } + int ciTableIdx_23 = (int) (local5); + int ciFuncId_23 = instance.table(0).requiredRef(ciTableIdx_23); + com.dylibso.chicory.runtime.Instance ciRefInstance_23 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_23), instance); + if (!ciRefInstance_23.type(ciRefInstance_23.functionType(ciFuncId_23)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 76)); + ciRefInstance_23.getMachine().call(ciFuncId_23, callArgs_23); + } + label_27: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 75), -1) != 0) { + break label_27; + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 64)); + instance.getMachine().call(1777, callArgs_24); + } + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 59), -1) != 0) { + break label_28; + } + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 48)); + instance.getMachine().call(1777, callArgs_25); + } + label_29: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 47), -1) != 0) { + break label_29; + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 36)); + instance.getMachine().call(1777, callArgs_26); + } + instance.global(0).setValue(((long) (local4 + 96))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_201(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_201(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_202(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 27643); + long[] callResult_0 = instance.getMachine().call(1864, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 0); + instance.getMachine().call(1827, callArgs_1); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_202(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_202(arg0, memory, instance); + return null; + } + + public static void func_203(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + int ciTableIdx_0 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return; + } + + public static long[] call_203(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_203(arg0, arg1, memory, instance); + return null; + } + + public static void func_204(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2), 60); + local4 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 71582789) != 0) { + break label_4; + } + label_5: { + label_6: { + local5 = (arg0 + 8); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) local5 < 0 ? local5 : local5 + 0) - local2), 60); + local6 = (local2 << 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 35791394) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local4) != 0 ? local6 : local4) : 71582788); + if (local4 != 0) { + break label_6; + } + local2 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 71582789) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 * 60)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + } + local7 = (local2 + (local3 * 60)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) local7); + callArgs_1[0] = ((long) local5); + instance.getMachine().call(205, callArgs_1); + local8 = (local2 + (local4 * 60)); + local9 = (local7 + 60); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local10 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local10, local6) != 0) { + break label_2; + } + arg1 = 0; + label_7: while (true) { + local4 = (local7 + arg1); + local2 = (local6 + arg1); + memory.writeByte((int) (local4 + -60) < 0 ? (local4 + -60) : (local4 + -60) + 0, (byte) (((int) memory.read((int) (local2 + -60) < 0 ? (local2 + -60) : (local2 + -60) + 0) & 0xFF))); + local5 = (local4 + -56); + local3 = (local2 + -56); + local11 = (local3 + 8); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) local11 < 0 ? local11 : local11 + 0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + local5 = (local4 + -44); + local3 = (local2 + -44); + local11 = (local3 + 8); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) local11 < 0 ? local11 : local11 + 0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + memory.writeByte((int) (local4 + -32) < 0 ? (local4 + -32) : (local4 + -32) + 0, (byte) (((int) memory.read((int) (local2 + -32) < 0 ? (local2 + -32) : (local2 + -32) + 0) & 0xFF))); + local5 = (local4 + -28); + local3 = (local2 + -28); + local11 = (local3 + 8); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) local11 < 0 ? local11 : local11 + 0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + memory.writeLong((int) (local4 + -16) < 0 ? (local4 + -16) : (local4 + -16) + 0, (long) memory.readLong((int) (local2 + -16) < 0 ? (local2 + -16) : (local2 + -16) + 0)); + local3 = (local2 + -8); + memory.writeI32((int) (local4 + -8) < 0 ? (local4 + -8) : (local4 + -8) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + local2 = (local2 + -4); + _snap_0 = local4; + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + memory.writeI32((int) (_snap_0 + -4) < 0 ? (_snap_0 + -4) : (_snap_0 + -4) + 0, (int) local4); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) local4 < 0 ? local4 : local4 + 4)) != 0) { + break label_8; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 36); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 41476); + } + arg1 = (arg1 + -60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local10, (local6 + arg1)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local8); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local9); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local7 + arg1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_1; + } + local4 = (local4 + -56); + label_9: while (true) { + label_10: { + local2 = memory.readInt((int) memory.readInt((int) (local4 + 52) < 0 ? (local4 + 52) : (local4 + 52) + 0) < 0 ? memory.readInt((int) (local4 + 52) < 0 ? (local4 + 52) : (local4 + 52) + 0) : memory.readInt((int) (local4 + 52) < 0 ? (local4 + 52) : (local4 + 52) + 0) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_10; + } + int ciTableIdx_2 = (int) (local2); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) (local4 + 40) < 0 ? (local4 + 40) : (local4 + 40) + 0)); + ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local4 + 39) < 0 ? (local4 + 39) : (local4 + 39) + 0), -1) != 0) { + break label_11; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0)); + instance.getMachine().call(1777, callArgs_3); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local4 + 23) < 0 ? (local4 + 23) : (local4 + 23) + 0), -1) != 0) { + break label_12; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0)); + instance.getMachine().call(1777, callArgs_4); + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local4 + 11) < 0 ? (local4 + 11) : (local4 + 11) + 0), -1) != 0) { + break label_13; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_5); + } + local2 = (local4 + -4); + local4 = (local4 + -60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_14; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_8); + } + return; + } + + public static long[] call_204(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_204(arg0, arg1, memory, instance); + return null; + } + + public static void func_205(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF))); + local3 = (arg1 + 4); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg2 < 0 ? arg2 : arg2 + 15), 0) != 0) { + break label_2; + } + local4 = (arg2 + 4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + callArgs_0[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4)); + callArgs_0[0] = ((long) local3); + instance.getMachine().call(1647, callArgs_0); + } + local3 = (arg1 + 16); + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg2 < 0 ? arg2 : arg2 + 27), 0) != 0) { + break label_4; + } + local4 = (arg2 + 16); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + break label_3; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0)); + callArgs_1[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 16)); + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1647, callArgs_1); + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 28, (byte) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 28) & 0xFF))); + local3 = (arg1 + 32); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg2 < 0 ? arg2 : arg2 + 43), 0) != 0) { + break label_6; + } + local4 = (arg2 + 32); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + break label_5; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) memory.readInt((int) (arg2 + 36) < 0 ? (arg2 + 36) : (arg2 + 36) + 0)); + callArgs_2[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 32)); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(1647, callArgs_2); + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 44, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 44)); + memory.writeI32((int) (arg1 + 52) < 0 ? (arg1 + 52) : (arg1 + 52) + 0, (int) memory.readInt((int) (arg2 + 52) < 0 ? (arg2 + 52) : (arg2 + 52) + 0)); + local3 = memory.readInt((int) (arg2 + 56) < 0 ? (arg2 + 56) : (arg2 + 56) + 0); + memory.writeI32((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0, (int) local3); + label_7: { + local3 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_7; + } + int ciTableIdx_3 = (int) (local3); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 44)); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 44, (int) ((int) callResult_3[0])); + } + return; + } + + public static long[] call_205(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_205(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_206(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg2); + label_1: { + label_2: { + local5 = memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, memory.readInt((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0)) != 0) { + break label_2; + } + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), 0) != 0) { + break label_4; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_3; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) local5); + instance.getMachine().call(1647, callArgs_0); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg2); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 16, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeI32((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (int) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 8)); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 12); + memory.writeI32((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (int) arg1); + label_5: { + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + int ciTableIdx_1 = (int) (arg1); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0)); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) ((int) callResult_1[0])); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 32, (int) 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 40, (int) (local5 + 36)); + break label_1; + } + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) arg3); + callArgs_2[2] = ((long) (local4 + 12)); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) (arg0 + 36)); + instance.getMachine().call(207, callArgs_2); + } + instance.global(0).setValue(((long) (local4 + 16))); + return; + } + + public static long[] call_206(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_206(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_207(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + int local10 = 0; + int local11 = 0; + int local12 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local4), 36); + local6 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 119304648) != 0) { + break label_4; + } + local7 = 0; + label_5: { + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local4), 36); + local8 = (local4 << 1); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6) : 119304647); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 119304648) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local6 * 36)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local7 = ((int) callResult_0[0]); + } + local8 = (local7 + (local5 * 36)); + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), 0) != 0) { + break label_7; + } + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_6; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_1[0] = ((long) local8); + instance.getMachine().call(1647, callArgs_1); + } + local6 = (local6 * 36); + arg1 = (local7 + (local5 * 36)); + local9 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 16, (long) local9); + memory.writeI32((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (int) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 8)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 12, (int) local4); + arg3 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 12); + memory.writeI32((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (int) arg3); + label_8: { + arg3 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_8; + } + int ciTableIdx_2 = (int) (arg3); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (int) local9); + long[] callResult_2 = ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) ((int) callResult_2[0])); + } + local10 = (local7 + local6); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 32, (int) 0); + local11 = (local8 + 36); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local12 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local12, local5) != 0) { + break label_2; + } + arg3 = 0; + label_9: while (true) { + arg1 = (local8 + arg3); + local4 = (arg1 + -36); + local7 = (local5 + arg3); + local6 = (local7 + -36); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + _snap_0 = local4; + local4 = (local6 + 8); + memory.writeI32((int) (_snap_0 + 8) < 0 ? (_snap_0 + 8) : (_snap_0 + 8) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + memory.writeI32((int) (arg1 + -24) < 0 ? (arg1 + -24) : (arg1 + -24) + 0, (int) memory.readInt((int) (local7 + -24) < 0 ? (local7 + -24) : (local7 + -24) + 0)); + memory.writeLong((int) (arg1 + -20) < 0 ? (arg1 + -20) : (arg1 + -20) + 0, (long) memory.readLong((int) (local7 + -20) < 0 ? (local7 + -20) : (local7 + -20) + 0)); + local4 = (local7 + -12); + memory.writeI32((int) (arg1 + -12) < 0 ? (arg1 + -12) : (arg1 + -12) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + arg2 = (local7 + -8); + local6 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) (arg1 + -8) < 0 ? (arg1 + -8) : (arg1 + -8) + 0, (int) local6); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) local6 < 0 ? local6 : local6 + 4)) != 0) { + break label_10; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 36); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 41476); + } + memory.writeI32((int) (arg1 + -4) < 0 ? (arg1 + -4) : (arg1 + -4) + 0, (int) memory.readInt((int) (local7 + -4) < 0 ? (local7 + -4) : (local7 + -4) + 0)); + arg3 = (arg3 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local12, (local5 + arg3)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local10); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local11); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local8 + arg3)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, arg1) != 0) { + break label_1; + } + arg1 = (arg1 + -36); + label_11: while (true) { + label_12: { + local7 = memory.readInt((int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0) < 0 ? memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0) : memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_12; + } + int ciTableIdx_3 = (int) (local7); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (arg1 + 11) < 0 ? (arg1 + 11) : (arg1 + 11) + 0), -1) != 0) { + break label_13; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_4); + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, arg1); + arg1 = (arg1 + -36); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local11); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local8); + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_14; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_7); + } + return; + } + + public static long[] call_207(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_207(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_208(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + int local10 = 0; + int local11 = 0; + local5 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local5)); + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg2); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local6 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 2147483632) != 0) { + break label_1; + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 10) != 0) { + break label_3; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 27, (byte) (local6)); + local7 = (local5 + 16); + break label_2; + } + local8 = ((local6 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local8); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) (local8 | -2147483648)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local6); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local6); + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(1890, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local6) < 0 ? (((int) callResult_2[0]) + local6) : (((int) callResult_2[0]) + local6) + 0, (byte) (0)); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg3); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local6 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 2147483632) != 0) { + break label_1; + } + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 10) != 0) { + break label_5; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 11, (byte) (local6)); + arg2 = local5; + break label_4; + } + local7 = ((local6 | 15) + 1); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local7); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg2 = ((int) callResult_4[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) (local7 | -2147483648)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local6); + callArgs_5[1] = ((long) arg3); + callArgs_5[0] = ((long) arg2); + long[] callResult_5 = instance.getMachine().call(1890, callArgs_5); + memory.writeByte((int) (((int) callResult_5[0]) + local6) < 0 ? (((int) callResult_5[0]) + local6) : (((int) callResult_5[0]) + local6) + 0, (byte) (0)); + local7 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 8); + arg2 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0); + local9 = ((long) memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 4) & 0xFFFFFFFFL); + label_6: { + arg3 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 12); + local6 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_6; + } + int ciTableIdx_6 = (int) (local6); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg2); + long[] callResult_6 = ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg2 = ((int) callResult_6[0]); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) 16); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + local6 = ((int) callResult_7[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local7); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) ((local9 << 32L) | com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg2))); + memory.writeI32((int) (local6 + 12) < 0 ? (local6 + 12) : (local6 + 12) + 0, (int) arg3); + label_7: { + arg4 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_7; + } + int ciTableIdx_8 = (int) (arg4); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg2); + long[] callResult_8 = ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) ((int) callResult_8[0])); + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 32, (byte) (arg1)); + arg1 = ((local5 + 32) | 4); + label_8: { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 27), 0) != 0) { + break label_9; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 16)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) ((local5 + 16) + 8) < 0 ? ((local5 + 16) + 8) : ((local5 + 16) + 8) + 0)); + break label_8; + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 20)); + callArgs_9[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 16)); + callArgs_9[0] = ((long) arg1); + instance.getMachine().call(1647, callArgs_9); + } + memory.writeLong((int) (local5 + 53) < 0 ? (local5 + 53) : (local5 + 53) + 0, (long) 0L); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 48, (long) 0L); + local8 = (local5 + 64); + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 11), 0) != 0) { + break label_11; + } + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (int) memory.readInt((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + break label_10; + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 4)); + callArgs_10[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + callArgs_10[0] = ((long) local8); + instance.getMachine().call(1647, callArgs_10); + } + memory.writeI32((int) (local5 + 88) < 0 ? (local5 + 88) : (local5 + 88) + 0, (int) 41672); + memory.writeI32((int) (local5 + 84) < 0 ? (local5 + 84) : (local5 + 84) + 0, (int) 37); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 76, (int) local6); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) 16); + long[] callResult_11 = instance.getMachine().call(1776, callArgs_11); + arg4 = ((int) callResult_11[0]); + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 0); + memory.writeLong((int) arg4 < 0 ? arg4 : arg4 + 0, (long) local9); + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 8, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 8)); + local10 = (local6 + 12); + local7 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 12, (int) local7); + label_12: { + local11 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_12; + } + int ciTableIdx_12 = (int) (local11); + int ciFuncId_12 = instance.table(0).requiredRef(ciTableIdx_12); + com.dylibso.chicory.runtime.Instance ciRefInstance_12 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_12), instance); + if (!ciRefInstance_12.type(ciRefInstance_12.functionType(ciFuncId_12)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) (int) local9); + long[] callResult_12 = ciRefInstance_12.getMachine().call(ciFuncId_12, callArgs_12); + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 0, (int) ((int) callResult_12[0])); + local7 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 76, (int) arg4); + label_13: { + arg4 = memory.readInt((int) (local7 + 4) < 0 ? (local7 + 4) : (local7 + 4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_13; + } + int ciTableIdx_13 = (int) (arg4); + int ciFuncId_13 = instance.table(0).requiredRef(ciTableIdx_13); + com.dylibso.chicory.runtime.Instance ciRefInstance_13 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_13), instance); + if (!ciRefInstance_13.type(ciRefInstance_13.functionType(ciFuncId_13)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + ciRefInstance_13.getMachine().call(ciFuncId_13, callArgs_13); + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_14); + label_14: { + local6 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_14; + } + int ciTableIdx_15 = (int) (local6); + int ciFuncId_15 = instance.table(0).requiredRef(ciTableIdx_15); + com.dylibso.chicory.runtime.Instance ciRefInstance_15 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_15), instance); + if (!ciRefInstance_15.type(ciRefInstance_15.functionType(ciFuncId_15)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) arg2); + ciRefInstance_15.getMachine().call(ciFuncId_15, callArgs_15); + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 11), -1) != 0) { + break label_15; + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + instance.getMachine().call(1777, callArgs_16); + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 27), -1) != 0) { + break label_16; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 16)); + instance.getMachine().call(1777, callArgs_17); + } + label_17: { + label_18: { + local6 = memory.readInt((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0)) != 0) { + break label_18; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 0, (byte) (((int) memory.read((int) local5 < 0 ? local5 : local5 + 32) & 0xFF))); + arg4 = (local6 + 4); + label_19: { + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 47), 0) != 0) { + break label_20; + } + memory.writeLong((int) arg4 < 0 ? arg4 : arg4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg4 + 8) < 0 ? (arg4 + 8) : (arg4 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_19; + } + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) memory.readInt((int) (local5 + 40) < 0 ? (local5 + 40) : (local5 + 40) + 0)); + callArgs_18[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 36)); + callArgs_18[0] = ((long) arg4); + instance.getMachine().call(1647, callArgs_18); + } + arg4 = (local6 + 16); + label_21: { + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 59), 0) != 0) { + break label_22; + } + arg2 = (local5 + 48); + memory.writeLong((int) arg4 < 0 ? arg4 : arg4 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeI32((int) (arg4 + 8) < 0 ? (arg4 + 8) : (arg4 + 8) + 0, (int) memory.readInt((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + break label_21; + } + long[] callArgs_19 = new long[3]; + callArgs_19[2] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 52)); + callArgs_19[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 48)); + callArgs_19[0] = ((long) arg4); + instance.getMachine().call(1647, callArgs_19); + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 28, (byte) (((int) memory.read((int) local5 < 0 ? local5 : local5 + 60) & 0xFF))); + arg4 = (local6 + 32); + label_23: { + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 75), 0) != 0) { + break label_24; + } + memory.writeLong((int) arg4 < 0 ? arg4 : arg4 + 0, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeI32((int) (arg4 + 8) < 0 ? (arg4 + 8) : (arg4 + 8) + 0, (int) memory.readInt((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0)); + break label_23; + } + long[] callArgs_20 = new long[3]; + callArgs_20[2] = ((long) memory.readInt((int) (local5 + 68) < 0 ? (local5 + 68) : (local5 + 68) + 0)); + callArgs_20[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 64)); + callArgs_20[0] = ((long) arg4); + instance.getMachine().call(1647, callArgs_20); + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 44, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 76)); + memory.writeI32((int) (local6 + 52) < 0 ? (local6 + 52) : (local6 + 52) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 84)); + arg4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 88); + memory.writeI32((int) (local6 + 56) < 0 ? (local6 + 56) : (local6 + 56) + 0, (int) arg4); + label_25: { + arg4 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_25; + } + int ciTableIdx_21 = (int) (arg4); + int ciFuncId_21 = instance.table(0).requiredRef(ciTableIdx_21); + com.dylibso.chicory.runtime.Instance ciRefInstance_21 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_21), instance); + if (!ciRefInstance_21.type(ciRefInstance_21.functionType(ciFuncId_21)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 76)); + long[] callResult_21 = ciRefInstance_21.getMachine().call(ciFuncId_21, callArgs_21); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 44, (int) ((int) callResult_21[0])); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 28, (int) (local6 + 60)); + break label_17; + } + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) (local5 + 32)); + callArgs_22[0] = ((long) (arg0 + 24)); + instance.getMachine().call(204, callArgs_22); + } + label_26: { + local6 = memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 88) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 88) : memory.readInt((int) local5 < 0 ? local5 : local5 + 88) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_26; + } + int ciTableIdx_23 = (int) (local6); + int ciFuncId_23 = instance.table(0).requiredRef(ciTableIdx_23); + com.dylibso.chicory.runtime.Instance ciRefInstance_23 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_23), instance); + if (!ciRefInstance_23.type(ciRefInstance_23.functionType(ciFuncId_23)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 76)); + ciRefInstance_23.getMachine().call(ciFuncId_23, callArgs_23); + } + label_27: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 75), -1) != 0) { + break label_27; + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 64)); + instance.getMachine().call(1777, callArgs_24); + } + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 59), -1) != 0) { + break label_28; + } + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 48)); + instance.getMachine().call(1777, callArgs_25); + } + label_29: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 47), -1) != 0) { + break label_29; + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 36)); + instance.getMachine().call(1777, callArgs_26); + } + instance.global(0).setValue(((long) (local5 + 96))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_208(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_208(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static void func_209(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + int ciTableIdx_0 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return; + } + + public static long[] call_209(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_209(arg0, arg1, memory, instance); + return null; + } + + public static void func_210(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + local6 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local6)); + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg2); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 2147483632) != 0) { + break label_1; + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, 10) != 0) { + break label_3; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 43, (byte) (local7)); + local8 = (local6 + 32); + break label_2; + } + local9 = ((local7 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local8 = ((int) callResult_1[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 40, (int) (local9 | -2147483648)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) local8); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 36, (int) local7); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local7); + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) local8); + long[] callResult_2 = instance.getMachine().call(1890, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local7) < 0 ? (((int) callResult_2[0]) + local7) : (((int) callResult_2[0]) + local7) + 0, (byte) (0)); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg3); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local7 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 2147483632) != 0) { + break label_1; + } + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, 10) != 0) { + break label_5; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 27, (byte) (local7)); + arg2 = (local6 + 16); + break label_4; + } + local8 = ((local7 | 15) + 1); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local8); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg2 = ((int) callResult_4[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) (local8 | -2147483648)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) local7); + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local7); + callArgs_5[1] = ((long) arg3); + callArgs_5[0] = ((long) arg2); + long[] callResult_5 = instance.getMachine().call(1890, callArgs_5); + memory.writeByte((int) (((int) callResult_5[0]) + local7) < 0 ? (((int) callResult_5[0]) + local7) : (((int) callResult_5[0]) + local7) + 0, (byte) (0)); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg4); + long[] callResult_6 = instance.getMachine().call(1897, callArgs_6); + local7 = ((int) callResult_6[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 2147483632) != 0) { + break label_1; + } + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, 10) != 0) { + break label_7; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 11, (byte) (local7)); + arg2 = local6; + break label_6; + } + arg3 = ((local7 | 15) + 1); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg3); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + arg2 = ((int) callResult_7[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) (arg3 | -2147483648)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local7); + } + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) local7); + callArgs_8[1] = ((long) arg4); + callArgs_8[0] = ((long) arg2); + long[] callResult_8 = instance.getMachine().call(1890, callArgs_8); + memory.writeByte((int) (((int) callResult_8[0]) + local7) < 0 ? (((int) callResult_8[0]) + local7) : (((int) callResult_8[0]) + local7) + 0, (byte) (0)); + memory.writeByte((int) local6 < 0 ? local6 : local6 + 48, (byte) (arg1)); + arg2 = ((local6 + 48) | 4); + label_8: { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 43), 0) != 0) { + break label_9; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 32)); + memory.writeI32((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (int) memory.readInt((int) ((local6 + 32) + 8) < 0 ? ((local6 + 32) + 8) : ((local6 + 32) + 8) + 0)); + break label_8; + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 36)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 32)); + callArgs_9[0] = ((long) arg2); + instance.getMachine().call(1647, callArgs_9); + } + arg3 = (local6 + 64); + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 27), 0) != 0) { + break label_11; + } + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 16)); + memory.writeI32((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (int) memory.readInt((int) ((local6 + 16) + 8) < 0 ? ((local6 + 16) + 8) : ((local6 + 16) + 8) + 0)); + break label_10; + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 20)); + callArgs_10[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 16)); + callArgs_10[0] = ((long) arg3); + instance.getMachine().call(1647, callArgs_10); + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 76, (byte) (1)); + arg4 = (local6 + 80); + label_12: { + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 11), 0) != 0) { + break label_13; + } + memory.writeLong((int) arg4 < 0 ? arg4 : arg4 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (arg4 + 8) < 0 ? (arg4 + 8) : (arg4 + 8) + 0, (int) memory.readInt((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + break label_12; + } + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 4)); + callArgs_11[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + callArgs_11[0] = ((long) arg4); + instance.getMachine().call(1647, callArgs_11); + } + memory.writeI32((int) (local6 + 100) < 0 ? (local6 + 100) : (local6 + 100) + 0, (int) memory.readInt((int) arg5 < 0 ? arg5 : arg5 + 8)); + local7 = memory.readInt((int) arg5 < 0 ? arg5 : arg5 + 12); + memory.writeI32((int) (local6 + 104) < 0 ? (local6 + 104) : (local6 + 104) + 0, (int) local7); + local10 = memory.readLong((int) arg5 < 0 ? arg5 : arg5 + 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 92, (long) local10); + label_14: { + local7 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_14; + } + int ciTableIdx_12 = (int) (local7); + int ciFuncId_12 = instance.table(0).requiredRef(ciTableIdx_12); + com.dylibso.chicory.runtime.Instance ciRefInstance_12 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_12), instance); + if (!ciRefInstance_12.type(ciRefInstance_12.functionType(ciFuncId_12)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) (int) local10); + long[] callResult_12 = ciRefInstance_12.getMachine().call(ciFuncId_12, callArgs_12); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 92, (int) ((int) callResult_12[0])); + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 11), -1) != 0) { + break label_15; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + instance.getMachine().call(1777, callArgs_13); + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 27), -1) != 0) { + break label_16; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 16)); + instance.getMachine().call(1777, callArgs_14); + } + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 43), -1) != 0) { + break label_17; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 32)); + instance.getMachine().call(1777, callArgs_15); + } + label_18: { + label_19: { + local7 = memory.readInt((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0)) != 0) { + break label_19; + } + memory.writeByte((int) local7 < 0 ? local7 : local7 + 0, (byte) (((int) memory.read((int) local6 < 0 ? local6 : local6 + 48) & 0xFF))); + arg5 = (local7 + 4); + label_20: { + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 63), 0) != 0) { + break label_21; + } + memory.writeLong((int) arg5 < 0 ? arg5 : arg5 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeI32((int) (arg5 + 8) < 0 ? (arg5 + 8) : (arg5 + 8) + 0, (int) memory.readInt((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + break label_20; + } + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) memory.readInt((int) (local6 + 56) < 0 ? (local6 + 56) : (local6 + 56) + 0)); + callArgs_16[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 52)); + callArgs_16[0] = ((long) arg5); + instance.getMachine().call(1647, callArgs_16); + } + arg5 = (local7 + 16); + label_22: { + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 75), 0) != 0) { + break label_23; + } + memory.writeLong((int) arg5 < 0 ? arg5 : arg5 + 0, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeI32((int) (arg5 + 8) < 0 ? (arg5 + 8) : (arg5 + 8) + 0, (int) memory.readInt((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + break label_22; + } + long[] callArgs_17 = new long[3]; + callArgs_17[2] = ((long) memory.readInt((int) (local6 + 68) < 0 ? (local6 + 68) : (local6 + 68) + 0)); + callArgs_17[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 64)); + callArgs_17[0] = ((long) arg5); + instance.getMachine().call(1647, callArgs_17); + } + memory.writeByte((int) local7 < 0 ? local7 : local7 + 28, (byte) (((int) memory.read((int) local6 < 0 ? local6 : local6 + 76) & 0xFF))); + arg5 = (local7 + 32); + label_24: { + label_25: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 91), 0) != 0) { + break label_25; + } + memory.writeLong((int) arg5 < 0 ? arg5 : arg5 + 0, (long) memory.readLong((int) arg4 < 0 ? arg4 : arg4 + 0)); + memory.writeI32((int) (arg5 + 8) < 0 ? (arg5 + 8) : (arg5 + 8) + 0, (int) memory.readInt((int) (arg4 + 8) < 0 ? (arg4 + 8) : (arg4 + 8) + 0)); + break label_24; + } + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) memory.readInt((int) (local6 + 84) < 0 ? (local6 + 84) : (local6 + 84) + 0)); + callArgs_18[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 80)); + callArgs_18[0] = ((long) arg5); + instance.getMachine().call(1647, callArgs_18); + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 44, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 92)); + memory.writeI32((int) (local7 + 52) < 0 ? (local7 + 52) : (local7 + 52) + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 100)); + arg5 = memory.readInt((int) local6 < 0 ? local6 : local6 + 104); + memory.writeI32((int) (local7 + 56) < 0 ? (local7 + 56) : (local7 + 56) + 0, (int) arg5); + label_26: { + arg5 = memory.readInt((int) arg5 < 0 ? arg5 : arg5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg5) != 0) { + break label_26; + } + int ciTableIdx_19 = (int) (arg5); + int ciFuncId_19 = instance.table(0).requiredRef(ciTableIdx_19); + com.dylibso.chicory.runtime.Instance ciRefInstance_19 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_19), instance); + if (!ciRefInstance_19.type(ciRefInstance_19.functionType(ciFuncId_19)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 92)); + long[] callResult_19 = ciRefInstance_19.getMachine().call(ciFuncId_19, callArgs_19); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 44, (int) ((int) callResult_19[0])); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 28, (int) (local7 + 60)); + break label_18; + } + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) (local6 + 48)); + callArgs_20[0] = ((long) (arg0 + 24)); + instance.getMachine().call(204, callArgs_20); + } + label_27: { + local7 = memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 104) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 104) : memory.readInt((int) local6 < 0 ? local6 : local6 + 104) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_27; + } + int ciTableIdx_21 = (int) (local7); + int ciFuncId_21 = instance.table(0).requiredRef(ciTableIdx_21); + com.dylibso.chicory.runtime.Instance ciRefInstance_21 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_21), instance); + if (!ciRefInstance_21.type(ciRefInstance_21.functionType(ciFuncId_21)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 92)); + ciRefInstance_21.getMachine().call(ciFuncId_21, callArgs_21); + } + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 91), -1) != 0) { + break label_28; + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 80)); + instance.getMachine().call(1777, callArgs_22); + } + label_29: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 75), -1) != 0) { + break label_29; + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 64)); + instance.getMachine().call(1777, callArgs_23); + } + label_30: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 63), -1) != 0) { + break label_30; + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 52)); + instance.getMachine().call(1777, callArgs_24); + } + instance.global(0).setValue(((long) (local6 + 112))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_210(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + Wat2WasmMachine.func_210(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + return null; + } + + public static void func_211(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local3)); + local4 = local3; + memory.writeI32((int) local4 < 0 ? local4 : local4 + 156, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 152, (int) arg2); + local5 = (local4 + 16); + label_1: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 128); + callArgs_0[0] = ((long) (local4 + 16)); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg2 = (((int) callResult_0[0]) + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 129) != 0) { + break label_1; + } + local5 = (local3 - ((arg2 + 15) & -16)); + instance.global(0).setValue(((long) local5)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 152)); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1875, callArgs_1); + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11), 0) != 0) { + break label_3; + } + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + break label_2; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + callArgs_2[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(1647, callArgs_2); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 31354); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = instance.getMachine().call(1662, callArgs_3); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local5); + callArgs_4[0] = ((long) local4); + long[] callResult_4 = instance.getMachine().call(1662, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 29046); + callArgs_5[0] = ((long) local4); + long[] callResult_5 = instance.getMachine().call(1662, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(3))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), 0) != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : local4)); + callArgs_6[0] = ((long) (arg0 + 48)); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_4; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_7); + } + instance.global(0).setValue(((long) (local4 + 160))); + return; + } + + public static long[] call_211(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_211(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_212(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + local4 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 2) != 0) { + break label_1; + } + local5 = 1; + local6 = 1; + local4 = 0; + label_2: while (true) { + local7 = memory.readInt((int) (arg2 + (local6 << 2)) < 0 ? (arg2 + (local6 << 2)) : (arg2 + (local6 << 2)) + 0); + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local5 & 1)) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, ((int) memory.read((int) local7 < 0 ? local7 : local7 + 0) & 0xFF)) != 0) { + break label_6; + } + } + label_8: { + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40) - local8), 36)) != 0) { + break label_8; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 112, (int) local7); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 112)); + callArgs_0[1] = ((long) 30617); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(211, callArgs_0); + break label_5; + } + local8 = (local8 + (local4 * 36)); + int ciTableIdx_1 = (int) (memory.readInt((int) (local8 + 24) < 0 ? (local8 + 24) : (local8 + 24) + 0)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(3))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local7); + callArgs_1[0] = ((long) (local8 + 16)); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 32, (int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 32) + 1)); + local4 = (local4 + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) local8 < 0 ? local8 : local8 + 12))); + break label_5; + } + label_9: { + label_10: { + local9 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 1) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, local9) != 0) { + break label_9; + } + local10 = (local7 + 1); + local11 = 1; + label_11: while (true) { + label_12: { + label_13: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24); + local12 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local12, local5) != 0) { + break label_13; + } + label_14: { + label_15: while (true) { + label_16: { + local8 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_16; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, (local9 & 255)) != 0) { + break label_16; + } + label_17: { + label_18: { + if (((int) memory.read((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0) & 0xFF) != 0) { + break label_18; + } + local12 = 0; + local8 = local6; + break label_17; + } + if (((int) memory.read((int) ((local11 + local7) + 1) < 0 ? ((local11 + local7) + 1) : ((local11 + local7) + 1) + 0) & 0xFF) != 0) { + break label_14; + } + local8 = (local6 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local8) != 0) { + break label_14; + } + local12 = memory.readInt((int) (arg2 + (local8 << 2)) < 0 ? (arg2 + (local8 << 2)) : (arg2 + (local8 << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, ((int) memory.read((int) local12 < 0 ? local12 : local12 + 0) & 0xFF)) != 0) { + break label_14; + } + } + int ciTableIdx_2 = (int) (memory.readInt((int) (local5 + 52) < 0 ? (local5 + 52) : (local5 + 52) + 0)); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(3))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local12); + callArgs_2[0] = ((long) (local5 + 44)); + ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + local6 = local8; + break label_12; + } + local5 = (local5 + 60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local12, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_15; + } + break label_13; + } + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local9)); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 32)); + callArgs_3[1] = ((long) 6763); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(211, callArgs_3); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) (int) (byte) memory.read((int) local10 < 0 ? local10 : local10 + 0)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local3 + 16)); + callArgs_4[1] = ((long) 30684); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(211, callArgs_4); + } + local5 = 1; + local11 = (local11 + 1); + local10 = (local7 + local11); + local9 = ((int) memory.read((int) local10 < 0 ? local10 : local10 + 0) & 0xFF); + if (local9 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break label_5; + } + } + label_19: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40) - local5), 36)) != 0) { + break label_19; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 96, (int) local7); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local3 + 96)); + callArgs_5[1] = ((long) 30617); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(211, callArgs_5); + local5 = 1; + break label_5; + } + local8 = (local5 + (local4 * 36)); + int ciTableIdx_6 = (int) (memory.readInt((int) (local8 + 24) < 0 ? (local8 + 24) : (local8 + 24) + 0)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(3))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local7); + callArgs_6[0] = ((long) (local8 + 16)); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + local5 = 1; + memory.writeI32((int) local8 < 0 ? local8 : local8 + 32, (int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 32) + 1)); + local4 = (local4 + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) local8 < 0 ? local8 : local8 + 12))); + break label_5; + } + label_20: { + if (((int) memory.read((int) local7 < 0 ? local7 : local7 + 2) & 0xFF) != 0) { + break label_20; + } + local5 = 0; + break label_5; + } + label_21: { + label_22: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local13 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local13, local5) != 0) { + break label_22; + } + local9 = (local7 + 2); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local13), 60); + local14 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 1) != 0 ? local5 : 1); + local15 = 0; + local16 = -1; + local10 = 0; + local17 = 0; + label_23: while (true) { + label_24: { + local5 = (local13 + (local10 * 60)); + local8 = ((int) memory.read((int) (local5 + 15) < 0 ? (local5 + 15) : (local5 + 15) + 0) & 0xFF); + _snap_0 = local8; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0) != 0 ? memory.readInt((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0) : _snap_0)) != 0) { + break label_24; + } + local12 = 0; + local18 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 28) & 0xFF); + label_25: { + label_26: { + local5 = (local5 + 4); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0) != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : local5); + local8 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_26; + } + local11 = (local5 + 1); + local5 = 0; + label_27: while (true) { + label_28: { + local12 = ((int) memory.read((int) (local9 + local5) < 0 ? (local9 + local5) : (local9 + local5) + 0) & 0xFF); + if (local12 != 0) { + break label_28; + } + local5 = local5; + break label_25; + } + label_29: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local8 & 255), local12) != 0) { + break label_29; + } + local5 = -1; + break label_25; + } + local8 = (local11 + local5); + local12 = (local5 + 1); + local5 = local12; + local8 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 0) & 0xFF); + if (local8 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_27; + } + break; + } + } + label_30: { + local8 = ((int) memory.read((int) (local9 + local12) < 0 ? (local9 + local12) : (local9 + local12) + 0) & 0xFF); + if (local8 != 0) { + break label_30; + } + local5 = (local12 + 1); + break label_25; + } + local5 = -1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local18 & 255)) != 0) { + break label_25; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(61, local8) != 0) { + break label_25; + } + local5 = local12; + } + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local5, local15) != 0) { + break label_31; + } + local17 = 1; + local15 = local5; + local16 = local10; + break label_24; + } + local17 = (local17 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local15, 0) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local15, local5))); + } + local10 = (local10 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local14, local10) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break; + } + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local17, 1) != 0) { + break label_32; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 64, (int) local7); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local3 + 64)); + callArgs_7[1] = ((long) 30642); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(211, callArgs_7); + local5 = 1; + break label_5; + } + if (local17 != 0) { + break label_21; + } + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) local7); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (local3 + 48)); + callArgs_8[1] = ((long) 30664); + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(211, callArgs_8); + local5 = 1; + break label_5; + } + label_33: { + label_34: { + label_35: { + local5 = (local13 + (local16 * 60)); + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 28) & 0xFF) != 0) { + break label_35; + } + local12 = 0; + break label_34; + } + local8 = (local15 + local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (local8 + 1) < 0 ? (local8 + 1) : (local8 + 1) + 0) & 0xFF)) != 0) { + break label_33; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(61, ((int) memory.read((int) (local8 + 2) < 0 ? (local8 + 2) : (local8 + 2) + 0) & 0xFF)) != 0) { + break label_33; + } + local12 = (local8 + 3); + } + local8 = local6; + break label_4; + } + label_36: { + local8 = (local6 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local8) != 0) { + break label_36; + } + local12 = memory.readInt((int) (arg2 + (local8 << 2)) < 0 ? (arg2 + (local8 << 2)) : (arg2 + (local8 << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(45, ((int) memory.read((int) local12 < 0 ? local12 : local12 + 0) & 0xFF)) != 0) { + break label_4; + } + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 80, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) (local5 + 15) < 0 ? (local5 + 15) : (local5 + 15) + 0), 0) != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 4) : (local5 + 4))); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local3 + 80)); + callArgs_9[1] = ((long) 6731); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(211, callArgs_9); + local5 = 1; + } + local8 = local6; + break label_3; + } + int ciTableIdx_10 = (int) (memory.readInt((int) (local5 + 52) < 0 ? (local5 + 52) : (local5 + 52) + 0)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(3))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) local12); + callArgs_10[0] = ((long) (local5 + 44)); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + local5 = 1; + } + local6 = (local8 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + label_37: { + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + local9 = memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, local8) != 0) { + break label_37; + } + if (memory.readInt((int) (local9 + -4) < 0 ? (local9 + -4) : (local9 + -4) + 0) != 0) { + break label_37; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local9 - local8), 36)) != 0) { + break label_37; + } + local5 = (local4 * 36); + label_38: while (true) { + label_39: { + local12 = (local8 + local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(2, memory.readInt((int) (local12 + 12) < 0 ? (local12 + 12) : (local12 + 12) + 0)) != 0) { + break label_39; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) (local12 + 11) < 0 ? (local12 + 11) : (local12 + 11) + 0), 0) != 0 ? memory.readInt((int) local12 < 0 ? local12 : local12 + 0) : local12)); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) local3); + callArgs_11[1] = ((long) 28909); + callArgs_11[0] = ((long) arg0); + instance.getMachine().call(211, callArgs_11); + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + } + local5 = (local5 + 36); + local4 = (local4 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local9 - local8), 36)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_38; + } + break; + } + } + instance.global(0).setValue(((long) (local3 + 128))); + return; + } + + public static long[] call_212(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_212(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_213(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local1 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local1)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 16, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11), 0) != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : arg0)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local1 + 16)); + callArgs_0[0] = ((long) 26775); + long[] callResult_0 = instance.getMachine().call(1863, callArgs_0); + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0)) != 0) { + break label_1; + } + local3 = 0; + local4 = 0; + label_2: while (true) { + label_3: { + local2 = (local2 + local3); + local5 = memory.readInt((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 2) != 0) { + break label_3; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) (local2 + 11) < 0 ? (local2 + 11) : (local2 + 11) + 0), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : local2)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local1); + callArgs_1[0] = ((long) memory.readInt((int) ((local5 << 2) + 41864) < 0 ? ((local5 << 2) + 41864) : ((local5 << 2) + 41864) + 0)); + long[] callResult_1 = instance.getMachine().call(1863, callArgs_1); + } + local3 = (local3 + 36); + local4 = (local4 + 1); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40) - local2), 36)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 38860); + long[] callResult_2 = instance.getMachine().call(1864, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 23), 0) != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : (arg0 + 12))); + long[] callResult_3 = instance.getMachine().call(1864, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 27549); + long[] callResult_4 = instance.getMachine().call(1864, callArgs_4); + label_4: { + label_5: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24); + local5 = memory.readInt((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local3); + if (local6 != 0) { + break label_5; + } + local4 = 0; + arg0 = local3; + label_6: while (true) { + label_7: { + local2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15) & 0xFF); + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0) != 0 ? memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0) : local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_7; + } + local7 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27) & 0xFF); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local7), 0) != 0 ? memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) : local7); + local2 = ((local7 != 0 ? (local7 + 1) : 0) + local2); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, local4) != 0 ? local2 : local4); + } + arg0 = (arg0 + 60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + if (local6 != 0) { + break label_5; + } + local6 = (local4 + 10); + label_8: while (true) { + label_9: { + label_10: { + if (((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF) != 0) { + break label_10; + } + arg0 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 15) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0) != 0 ? memory.readInt((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0) : arg0)) != 0) { + break label_9; + } + } + memory.writeI32((int) ((local1 + 80) + 8) < 0 ? ((local1 + 80) + 8) : ((local1 + 80) + 8) + 0, (int) 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 80, (long) 0L); + label_11: { + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF)) != 0) { + break label_12; + } + memory.writeShort((int) local1 < 0 ? local1 : local1 + 32, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 29325) & 0xFFFF))); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 43, (byte) (3)); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 34, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 29327) & 0xFF))); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 35, (byte) (0)); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0)); + callArgs_5[0] = ((long) (local1 + 32)); + instance.getMachine().call(1660, callArgs_5); + arg0 = ((local1 + 32) + 8); + memory.writeI32((int) ((local1 + 48) + 8) < 0 ? ((local1 + 48) + 8) : ((local1 + 48) + 8) + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 48, (long) memory.readLong((int) local1 < 0 ? local1 : local1 + 32)); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 32, (long) 0L); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 31370); + callArgs_6[0] = ((long) (local1 + 48)); + long[] callResult_6 = instance.getMachine().call(1662, callArgs_6); + arg0 = ((int) callResult_6[0]); + local2 = (arg0 + 8); + memory.writeI32((int) ((local1 + 64) + 8) < 0 ? ((local1 + 64) + 8) : ((local1 + 64) + 8) + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 64, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + arg0 = ((int) memory.read((int) local1 < 0 ? local1 : local1 + 75) & 0xFF); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local2 != 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 68) : arg0)); + callArgs_7[1] = ((long) (local2 != 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 64) : (local1 + 64))); + callArgs_7[0] = ((long) (local1 + 80)); + long[] callResult_7 = instance.getMachine().call(1652, callArgs_7); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 75), -1) != 0) { + break label_13; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 64)); + instance.getMachine().call(1777, callArgs_8); + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 59), -1) != 0) { + break label_14; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 48)); + instance.getMachine().call(1777, callArgs_9); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 43), -1) != 0) { + break label_11; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 32)); + instance.getMachine().call(1777, callArgs_10); + break label_11; + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 31373); + callArgs_11[0] = ((long) (local1 + 80)); + long[] callResult_11 = instance.getMachine().call(1662, callArgs_11); + } + memory.writeI32((int) ((local1 + 64) + 8) < 0 ? ((local1 + 64) + 8) : ((local1 + 64) + 8) + 0, (int) 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 64, (long) 0L); + label_15: { + local4 = (local3 + 8); + arg0 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 15); + local7 = (arg0 & 255); + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg0, 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg0 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : local7)) != 0) { + break label_15; + } + local2 = (local3 + 4); + memory.writeShort((int) local1 < 0 ? local1 : local1 + 64, (short) (11565)); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 75, (byte) (2)); + label_16: { + local8 = (local3 + 20); + local9 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local9, 0) != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 0) : (local9 & 255))) != 0) { + break label_16; + } + local7 = (arg0 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : local7); + local4 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 2147483632) != 0) { + break label_4; + } + local9 = (local3 + 16); + label_17: { + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 10) != 0) { + break label_18; + } + memory.writeI32((int) ((local1 + 32) + 8) < 0 ? ((local1 + 32) + 8) : ((local1 + 32) + 8) + 0, (int) 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 32, (long) 0L); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 43, (byte) (local4)); + local10 = (local1 + 32); + break label_17; + } + local11 = ((local4 | 15) + 1); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local11); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + local10 = ((int) callResult_12[0]); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 36, (int) local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 32, (int) local10); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 40, (int) (local11 | -2147483648)); + } + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) local7); + callArgs_13[1] = ((long) (arg0 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : local2)); + callArgs_13[0] = ((long) local10); + long[] callResult_13 = instance.getMachine().call(1891, callArgs_13); + memory.writeShort((int) (((int) callResult_13[0]) + local7) < 0 ? (((int) callResult_13[0]) + local7) : (((int) callResult_13[0]) + local7) + 0, (short) (61)); + arg0 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 27) & 0xFF); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0); + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) (local2 != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 0) : arg0)); + callArgs_14[1] = ((long) (local2 != 0 ? memory.readInt((int) local9 < 0 ? local9 : local9 + 0) : local9)); + callArgs_14[0] = ((long) (local1 + 32)); + long[] callResult_14 = instance.getMachine().call(1652, callArgs_14); + arg0 = ((int) callResult_14[0]); + local2 = (arg0 + 8); + memory.writeI32((int) ((local1 + 48) + 8) < 0 ? ((local1 + 48) + 8) : ((local1 + 48) + 8) + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 48, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + arg0 = ((int) memory.read((int) local1 < 0 ? local1 : local1 + 59) & 0xFF); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0); + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) (local2 != 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 52) : arg0)); + callArgs_15[1] = ((long) (local2 != 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 48) : (local1 + 48))); + callArgs_15[0] = ((long) (local1 + 64)); + long[] callResult_15 = instance.getMachine().call(1652, callArgs_15); + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 59), -1) != 0) { + break label_19; + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 48)); + instance.getMachine().call(1777, callArgs_16); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 43), -1) != 0) { + break label_15; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 32)); + instance.getMachine().call(1777, callArgs_17); + break label_15; + } + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) (arg0 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : local7)); + callArgs_18[1] = ((long) (arg0 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : local2)); + callArgs_18[0] = ((long) (local1 + 64)); + long[] callResult_18 = instance.getMachine().call(1652, callArgs_18); + } + arg0 = ((int) memory.read((int) local1 < 0 ? local1 : local1 + 75) & 0xFF); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0) != 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 68) : arg0); + arg0 = (local6 - local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, 2147483632) != 0) { + break label_4; + } + label_20: { + label_21: { + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, 11) != 0) { + break label_22; + } + local4 = ((arg0 | 15) + 1); + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) local4); + long[] callResult_19 = instance.getMachine().call(1776, callArgs_19); + local2 = ((int) callResult_19[0]); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 40, (int) (local4 | -2147483648)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 32, (int) local2); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 36, (int) arg0); + break label_21; + } + memory.writeByte((int) local1 < 0 ? local1 : local1 + 43, (byte) (arg0)); + local2 = (local1 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_20; + } + } + long[] callArgs_20 = new long[3]; + callArgs_20[2] = ((long) arg0); + callArgs_20[1] = ((long) 32); + callArgs_20[0] = ((long) local2); + long[] callResult_20 = instance.getMachine().call(1892, callArgs_20); + } + memory.writeByte((int) (local2 + arg0) < 0 ? (local2 + arg0) : (local2 + arg0) + 0, (byte) (0)); + arg0 = ((int) memory.read((int) local1 < 0 ? local1 : local1 + 75) & 0xFF); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0); + long[] callArgs_21 = new long[4]; + callArgs_21[3] = ((long) (local2 != 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 68) : arg0)); + callArgs_21[2] = ((long) (local2 != 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 64) : (local1 + 64))); + callArgs_21[1] = ((long) 0); + callArgs_21[0] = ((long) (local1 + 32)); + long[] callResult_21 = instance.getMachine().call(1648, callArgs_21); + arg0 = ((int) callResult_21[0]); + local2 = (arg0 + 8); + memory.writeI32((int) ((local1 + 48) + 8) < 0 ? ((local1 + 48) + 8) : ((local1 + 48) + 8) + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 48, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + arg0 = ((int) memory.read((int) local1 < 0 ? local1 : local1 + 59) & 0xFF); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0); + long[] callArgs_22 = new long[3]; + callArgs_22[2] = ((long) (local2 != 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 52) : arg0)); + callArgs_22[1] = ((long) (local2 != 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 48) : (local1 + 48))); + callArgs_22[0] = ((long) (local1 + 80)); + long[] callResult_22 = instance.getMachine().call(1652, callArgs_22); + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 59), -1) != 0) { + break label_23; + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 48)); + instance.getMachine().call(1777, callArgs_23); + } + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 43), -1) != 0) { + break label_24; + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 32)); + instance.getMachine().call(1777, callArgs_24); + } + label_25: { + arg0 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 43) & 0xFF); + _snap_0 = arg0; + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0); + local2 = (arg0 != 0 ? memory.readInt((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0) : _snap_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_25; + } + local4 = (local3 + 32); + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) local2); + callArgs_25[1] = ((long) (arg0 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : local4)); + callArgs_25[0] = ((long) (local1 + 80)); + long[] callResult_25 = instance.getMachine().call(1652, callArgs_25); + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 91), 0) != 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 80) : (local1 + 80))); + long[] callResult_26 = instance.getMachine().call(1864, callArgs_26); + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 75), -1) != 0) { + break label_26; + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 64)); + instance.getMachine().call(1777, callArgs_27); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 91), -1) != 0) { + break label_9; + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 80)); + instance.getMachine().call(1777, callArgs_28); + } + local3 = (local3 + 60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + instance.global(0).setValue(((long) (local1 + 96))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_213(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_213(arg0, memory, instance); + return null; + } + + public static void func_214(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(215, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_214(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_214(arg0, arg1, memory, instance); + return null; + } + + public static void func_215(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_215(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_215(memory, instance); + return null; + } + + public static int func_216(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + long local2 = 0L; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 16); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + local2 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) local2); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) arg0); + label_1: { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + int ciTableIdx_1 = (int) (arg0); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (int) local2); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) ((int) callResult_1[0])); + } + return local1; + } + + public static long[] call_216(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_216(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_217(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + local1 = memory.readInt((int) (memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0) + 4) < 0 ? (memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0) + 4) : (memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0) + 4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + int ciTableIdx_0 = (int) (local1); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_217(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_217(arg0, memory, instance); + return null; + } + + public static int func_218(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + long local2 = 0L; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 16); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + local2 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) local2); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) arg0); + label_1: { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + int ciTableIdx_1 = (int) (arg0); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (int) local2); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) ((int) callResult_1[0])); + } + return local1; + } + + public static long[] call_218(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_218(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_219(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + local1 = memory.readInt((int) (memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0) + 4) < 0 ? (memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0) + 4) : (memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0) + 4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + int ciTableIdx_0 = (int) (local1); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_219(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_219(arg0, memory, instance); + return null; + } + + public static void func_220(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + arg1)); + return; + } + + public static long[] call_220(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_220(arg0, arg1, memory, instance); + return null; + } + + public static void func_221(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)) != 0) { + break label_1; + } + label_2: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + long[] callArgs_0 = new long[7]; + callArgs_0[6] = ((long) arg4); + callArgs_0[5] = ((long) 0); + callArgs_0[4] = ((long) arg5); + callArgs_0[3] = ((long) arg1); + callArgs_0[2] = ((long) arg3); + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) local6); + instance.getMachine().call(222, callArgs_0); + } + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) arg3); + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) ((int) callResult_1[0])); + } + return; + } + + public static long[] call_221(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + Wat2WasmMachine.func_221(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + return null; + } + + public static void func_222(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local7 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local7)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg2, 1) != 0) { + break label_1; + } + local8 = (arg1 + arg2); + local9 = (arg3 - arg1); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, arg4); + label_2: while (true) { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg5) != 0) { + break label_3; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 64, (int) arg5); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local7 + 64)); + callArgs_0[1] = ((long) 11317); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(223, callArgs_0); + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 48, (int) (local9 + arg1)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local7 + 48)); + callArgs_1[1] = ((long) 31120); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(223, callArgs_1); + arg2 = 0; + label_4: while (true) { + label_5: { + label_6: { + arg4 = (arg1 + arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg4, local8) != 0) { + break label_6; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) ((int) memory.read((int) arg4 < 0 ? arg4 : arg4 + 0) & 0xFF)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local7 + 32)); + callArgs_2[1] = ((long) 2570); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(223, callArgs_2); + break label_5; + } + memory.writeByte((int) local7 < 0 ? local7 : local7 + 79, (byte) (32)); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)) != 0) { + break label_8; + } + arg3 = (arg3 + 1); + break label_7; + } + label_9: { + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_9; + } + long[] callArgs_3 = new long[7]; + callArgs_3[6] = ((long) 0); + callArgs_3[5] = ((long) 0); + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) (local7 + 79)); + callArgs_3[0] = ((long) local11); + instance.getMachine().call(222, callArgs_3); + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) 1); + callArgs_4[2] = ((long) (local7 + 79)); + callArgs_4[1] = ((long) arg3); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + local11 = ((int) callResult_4[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local11); + arg3 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg3); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 79, (byte) (32)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local11) != 0) { + break label_7; + } + label_10: { + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_10; + } + long[] callArgs_5 = new long[7]; + callArgs_5[6] = ((long) 0); + callArgs_5[5] = ((long) 0); + callArgs_5[4] = ((long) 0); + callArgs_5[3] = ((long) arg3); + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local7 + 79)); + callArgs_5[0] = ((long) local11); + instance.getMachine().call(222, callArgs_5); + } + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) 1); + callArgs_6[2] = ((long) (local7 + 79)); + callArgs_6[1] = ((long) arg3); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) ((int) callResult_6[0])); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg3 + 1)); + } + label_11: { + label_12: { + arg4 = (arg4 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg4, local8) != 0) { + break label_12; + } + memory.writeByte((int) local7 < 0 ? local7 : local7 + 79, (byte) (32)); + arg4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + label_13: { + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)) != 0) { + break label_14; + } + label_15: { + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_15; + } + long[] callArgs_7 = new long[7]; + callArgs_7[6] = ((long) 0); + callArgs_7[5] = ((long) 0); + callArgs_7[4] = ((long) 0); + callArgs_7[3] = ((long) arg4); + callArgs_7[2] = ((long) 1); + callArgs_7[1] = ((long) (local7 + 79)); + callArgs_7[0] = ((long) arg3); + instance.getMachine().call(222, callArgs_7); + } + arg3 = 1; + int ciTableIdx_8 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 1); + callArgs_8[2] = ((long) (local7 + 79)); + callArgs_8[1] = ((long) arg4); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + local11 = ((int) callResult_8[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local11); + arg4 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg4); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 79, (byte) (32)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local11) != 0) { + break label_13; + } + label_16: { + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_16; + } + long[] callArgs_9 = new long[7]; + callArgs_9[6] = ((long) 0); + callArgs_9[5] = ((long) 0); + callArgs_9[4] = ((long) 0); + callArgs_9[3] = ((long) arg4); + callArgs_9[2] = ((long) 1); + callArgs_9[1] = ((long) (local7 + 79)); + callArgs_9[0] = ((long) arg3); + instance.getMachine().call(222, callArgs_9); + } + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[4]; + callArgs_10[3] = ((long) 1); + callArgs_10[2] = ((long) (local7 + 79)); + callArgs_10[1] = ((long) arg4); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg3 = ((int) callResult_10[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg3); + arg4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + break label_13; + } + arg3 = 1; + arg4 = (arg4 + 1); + } + arg4 = (arg4 + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg4); + break label_11; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 16, (int) ((int) memory.read((int) arg4 < 0 ? arg4 : arg4 + 0) & 0xFF)); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local7 + 16)); + callArgs_11[1] = ((long) 2570); + callArgs_11[0] = ((long) arg0); + instance.getMachine().call(223, callArgs_11); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + arg4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeByte((int) local7 < 0 ? local7 : local7 + 79, (byte) (32)); + arg2 = (arg2 + 2); + local11 = 1; + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3) != 0) { + break label_17; + } + label_18: { + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_18; + } + long[] callArgs_12 = new long[7]; + callArgs_12[6] = ((long) 0); + callArgs_12[5] = ((long) 0); + callArgs_12[4] = ((long) 0); + callArgs_12[3] = ((long) arg4); + callArgs_12[2] = ((long) 1); + callArgs_12[1] = ((long) (local7 + 79)); + callArgs_12[0] = ((long) arg3); + instance.getMachine().call(222, callArgs_12); + } + int ciTableIdx_13 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_13 = instance.table(0).requiredRef(ciTableIdx_13); + com.dylibso.chicory.runtime.Instance ciRefInstance_13 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_13), instance); + if (!ciRefInstance_13.type(ciRefInstance_13.functionType(ciFuncId_13)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_13 = new long[4]; + callArgs_13[3] = ((long) 1); + callArgs_13[2] = ((long) (local7 + 79)); + callArgs_13[1] = ((long) arg4); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = ciRefInstance_13.getMachine().call(ciFuncId_13, callArgs_13); + local11 = ((int) callResult_13[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local11); + arg4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + arg3 = (arg4 + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((arg2 + -1), 15) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + label_19: { + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_20; + } + arg1 = (arg1 + 16); + break label_19; + } + memory.writeByte((int) local7 < 0 ? local7 : local7 + 79, (byte) (32)); + label_21: { + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local11) != 0) { + break label_22; + } + label_23: { + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_23; + } + long[] callArgs_14 = new long[7]; + callArgs_14[6] = ((long) 0); + callArgs_14[5] = ((long) 0); + callArgs_14[4] = ((long) 0); + callArgs_14[3] = ((long) arg3); + callArgs_14[2] = ((long) 1); + callArgs_14[1] = ((long) (local7 + 79)); + callArgs_14[0] = ((long) arg2); + instance.getMachine().call(222, callArgs_14); + } + int ciTableIdx_15 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_15 = instance.table(0).requiredRef(ciTableIdx_15); + com.dylibso.chicory.runtime.Instance ciRefInstance_15 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_15), instance); + if (!ciRefInstance_15.type(ciRefInstance_15.functionType(ciFuncId_15)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_15 = new long[4]; + callArgs_15[3] = ((long) 1); + callArgs_15[2] = ((long) (local7 + 79)); + callArgs_15[1] = ((long) arg3); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = ciRefInstance_15.getMachine().call(ciFuncId_15, callArgs_15); + local11 = ((int) callResult_15[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local11); + arg3 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local8) != 0) { + break label_19; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local11) != 0) { + break label_21; + } + arg2 = 0; + local12 = local11; + label_24: while (true) { + arg4 = ((int) memory.read((int) (arg1 + arg2) < 0 ? (arg1 + arg2) : (arg1 + arg2) + 0) & 0xFF); + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) arg4); + long[] callResult_16 = instance.getMachine().call(1819, callArgs_16); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 79, (byte) ((((int) callResult_16[0]) != 0 ? arg4 : 46))); + label_25: { + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local12) != 0) { + break label_26; + } + local12 = 1; + break label_25; + } + label_27: { + arg4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_27; + } + long[] callArgs_17 = new long[7]; + callArgs_17[6] = ((long) 0); + callArgs_17[5] = ((long) 0); + callArgs_17[4] = ((long) 0); + callArgs_17[3] = ((long) arg3); + callArgs_17[2] = ((long) 1); + callArgs_17[1] = ((long) (local7 + 79)); + callArgs_17[0] = ((long) arg4); + instance.getMachine().call(222, callArgs_17); + } + int ciTableIdx_18 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_18 = instance.table(0).requiredRef(ciTableIdx_18); + com.dylibso.chicory.runtime.Instance ciRefInstance_18 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_18), instance); + if (!ciRefInstance_18.type(ciRefInstance_18.functionType(ciFuncId_18)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_18 = new long[4]; + callArgs_18[3] = ((long) 1); + callArgs_18[2] = ((long) (local7 + 79)); + callArgs_18[1] = ((long) arg3); + callArgs_18[0] = ((long) arg0); + long[] callResult_18 = ciRefInstance_18.getMachine().call(ciFuncId_18, callArgs_18); + local11 = ((int) callResult_18[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local11); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local12 = local11; + } + arg3 = (arg3 + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg3); + local13 = (arg2 + 1); + arg4 = (local13 + arg1); + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 14) != 0) { + break label_28; + } + arg2 = local13; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg4, local8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_24; + } + } + break; + } + arg1 = arg4; + break label_19; + } + arg3 = (arg4 + 2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg3); + local11 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local8) != 0) { + break label_19; + } + } + arg2 = 0; + label_29: { + label_30: while (true) { + arg4 = (arg2 + 1); + local12 = (arg4 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 14) != 0) { + break label_29; + } + arg2 = arg4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local12, local8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_30; + } + break; + } + } + arg3 = (arg3 + arg4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg3); + local11 = 1; + arg1 = local12; + } + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg6) != 0) { + break label_31; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, local8) != 0) { + break label_31; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) arg6); + long[] callArgs_19 = new long[3]; + callArgs_19[2] = ((long) local7); + callArgs_19[1] = ((long) 10792); + callArgs_19[0] = ((long) arg0); + instance.getMachine().call(223, callArgs_19); + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeByte((int) local7 < 0 ? local7 : local7 + 79, (byte) (10)); + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local11) != 0) { + break label_32; + } + label_33: { + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_33; + } + long[] callArgs_20 = new long[7]; + callArgs_20[6] = ((long) 0); + callArgs_20[5] = ((long) 0); + callArgs_20[4] = ((long) 0); + callArgs_20[3] = ((long) arg3); + callArgs_20[2] = ((long) 1); + callArgs_20[1] = ((long) (local7 + 79)); + callArgs_20[0] = ((long) arg2); + instance.getMachine().call(222, callArgs_20); + } + int ciTableIdx_21 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_21 = instance.table(0).requiredRef(ciTableIdx_21); + com.dylibso.chicory.runtime.Instance ciRefInstance_21 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_21), instance); + if (!ciRefInstance_21.type(ciRefInstance_21.functionType(ciFuncId_21)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_21 = new long[4]; + callArgs_21[3] = ((long) 1); + callArgs_21[2] = ((long) (local7 + 79)); + callArgs_21[1] = ((long) arg3); + callArgs_21[0] = ((long) arg0); + long[] callResult_21 = ciRefInstance_21.getMachine().call(ciFuncId_21, callArgs_21); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) ((int) callResult_21[0])); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg3 + 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, local8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + instance.global(0).setValue(((long) (local7 + 80))); + return; + } + + public static long[] call_222(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + Wat2WasmMachine.func_222(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + return null; + } + + public static void func_223(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + local4 = local3; + memory.writeI32((int) local4 < 0 ? local4 : local4 + 140, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 136, (int) arg2); + local5 = local4; + label_1: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 128); + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg2 = ((int) callResult_0[0]); + local6 = (arg2 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 129) != 0) { + break label_1; + } + local5 = (local3 - ((local6 + 15) & -16)); + instance.global(0).setValue(((long) local5)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 136)); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) local6); + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1875, callArgs_1); + arg2 = ((int) callResult_1[0]); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)) != 0) { + break label_2; + } + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + long[] callArgs_2 = new long[7]; + callArgs_2[6] = ((long) 0); + callArgs_2[5] = ((long) 0); + callArgs_2[4] = ((long) 0); + callArgs_2[3] = ((long) arg1); + callArgs_2[2] = ((long) arg2); + callArgs_2[1] = ((long) local5); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(222, callArgs_2); + } + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg2); + callArgs_3[2] = ((long) local5); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) ((int) callResult_3[0])); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg1 + arg2)); + instance.global(0).setValue(((long) (local4 + 144))); + return; + } + + public static long[] call_223(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_223(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_224(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)) != 0) { + break label_1; + } + label_2: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + long[] callArgs_0 = new long[7]; + callArgs_0[6] = ((long) arg3); + callArgs_0[5] = ((long) 0); + callArgs_0[4] = ((long) arg4); + callArgs_0[3] = ((long) local5); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) local6); + instance.getMachine().call(222, callArgs_0); + } + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) arg2); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) ((int) callResult_1[0])); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local5 + arg2)); + return; + } + + public static long[] call_224(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_224(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static void func_225(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)) != 0) { + break label_1; + } + label_2: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_2; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) (arg3 + arg1)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) (arg3 + arg2)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local4); + callArgs_0[1] = ((long) 32541); + callArgs_0[0] = ((long) local5); + instance.getMachine().call(223, callArgs_0); + } + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 16)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) arg3); + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) ((int) callResult_1[0])); + } + instance.global(0).setValue(((long) (local4 + 16))); + return; + } + + public static long[] call_225(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_225(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_226(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)) != 0) { + break label_1; + } + label_2: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 32514); + callArgs_0[0] = ((long) local3); + instance.getMachine().call(223, callArgs_0); + } + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 20)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local3); + if (local3 != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4), arg1) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + } + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_226(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_226(arg0, arg1, memory, instance); + return null; + } + + public static int func_227(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_3; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 43, (byte) (local3)); + arg1 = (local2 + 32); + break label_2; + } + local5 = ((local3 | 15) + 1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) (local5 | -2147483648)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) local3); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg1); + long[] callResult_1 = instance.getMachine().call(1891, callArgs_1); + memory.writeByte((int) (((int) callResult_1[0]) + local3) < 0 ? (((int) callResult_1[0]) + local3) : (((int) callResult_1[0]) + local3) + 0, (byte) (0)); + label_4: { + label_5: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 26535); + callArgs_2[0] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 32) : (local2 + 32))); + long[] callResult_2 = instance.getMachine().call(1846, callArgs_2); + arg1 = ((int) callResult_2[0]); + if (arg1 != 0) { + break label_5; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 26516); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) 139); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 32) : (local2 + 32))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 32239); + callArgs_3[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + long[] callResult_3 = instance.getMachine().call(1847, callArgs_3); + local3 = 1; + break label_4; + } + label_6: { + label_7: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local4) != 0) { + break label_7; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(1831, callArgs_4); + break label_6; + } + local3 = 1; + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) arg1); + callArgs_5[2] = ((long) (local5 - local4)); + callArgs_5[1] = ((long) 1); + callArgs_5[0] = ((long) local4); + long[] callResult_5 = instance.getMachine().call(1856, callArgs_5); + local4 = ((int) callResult_5[0]); + arg0 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + label_8: { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0) { + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, local4) != 0) { + break label_8; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 26516); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) 151); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) arg0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 32) : (local2 + 32))); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) (local2 + 16)); + callArgs_6[1] = ((long) 31459); + callArgs_6[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + long[] callResult_6 = instance.getMachine().call(1847, callArgs_6); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(1831, callArgs_7); + break label_4; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1831, callArgs_8); + } + local3 = 0; + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), -1) != 0) { + break label_10; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + instance.getMachine().call(1777, callArgs_9); + } + instance.global(0).setValue(((long) (local2 + 48))); + return local3; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_227(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_227(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_228(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_2; + } + local4 = 0; + break label_1; + } + local4 = 0; + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61636)); + callArgs_0[2] = ((long) (local3 - local2)); + callArgs_0[1] = ((long) 1); + callArgs_0[0] = ((long) local2); + long[] callResult_0 = instance.getMachine().call(1856, callArgs_0); + local2 = ((int) callResult_0[0]); + arg0 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local2, 0) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, local2) != 0) { + break label_1; + } + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) arg0); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) 166); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 26516); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 31400); + callArgs_1[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + long[] callResult_1 = instance.getMachine().call(1847, callArgs_1); + local4 = 1; + } + instance.global(0).setValue(((long) (local1 + 16))); + return local4; + } + + public static long[] call_228(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_228(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_229(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg1); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 41884); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 12); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) arg1); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) 0); + return arg0; + } + + public static long[] call_229(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_229(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_230(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) 0); + return local1; + } + + public static long[] call_230(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_230(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_231(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_1; + } + label_2: { + local4 = (arg3 + arg1); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local7 = (memory.readInt((int) local5 < 0 ? local5 : local5 + 4) - local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local4, local7) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 - local7)); + callArgs_0[0] = ((long) local5); + instance.getMachine().call(84, callArgs_0); + local6 = memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 0); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg3); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local6 + arg1)); + long[] callResult_1 = instance.getMachine().call(1890, callArgs_1); + } + return 0; + } + + public static long[] call_231(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_231(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_232(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_1; + } + label_2: { + local4 = (arg3 + arg2); + local5 = (arg3 + arg1); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, local5) != 0 ? local4 : local5); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local7 = (memory.readInt((int) local5 < 0 ? local5 : local5 + 4) - local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local6, local7) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 - local7)); + callArgs_0[0] = ((long) local5); + instance.getMachine().call(84, callArgs_0); + local4 = memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 0); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg3); + callArgs_1[1] = ((long) (local4 + arg2)); + callArgs_1[0] = ((long) (local4 + arg1)); + long[] callResult_1 = instance.getMachine().call(1891, callArgs_1); + } + return 0; + } + + public static long[] call_232(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_232(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_233(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = 1; + label_1: { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local4 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, arg1) != 0) { + break label_1; + } + local2 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local4, arg1) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local3 + arg1)); + } + return local2; + } + + public static long[] call_233(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_233(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_234(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 41916); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 24) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + long[] callResult_0 = instance.getMachine().call(1831, callArgs_0); + } + return arg0; + } + + public static long[] call_234(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_234(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_235(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 41916); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 24) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + long[] callResult_0 = instance.getMachine().call(1831, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_235(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_235(arg0, memory, instance); + return null; + } + + public static void func_236(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1833, callArgs_0); + } + return; + } + + public static long[] call_236(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_236(arg0, memory, instance); + return null; + } + + public static int func_237(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local4)); + local5 = 1; + label_1: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_2; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_3; + } + label_4: { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1852, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_0[0])) != 0) { + break label_4; + } + arg0 = memory.readInt((int) 0 < 0 ? 0 : 0 + 61628); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(0) != 0) { + break label_5; + } + instance.getMachine().call(16, new long[0]); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) 26516); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) 284); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 658184)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 16)); + callArgs_2[1] = ((long) 32288); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1847, callArgs_2); + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg1); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + } + label_6: { + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local6); + callArgs_3[2] = ((long) 1); + callArgs_3[1] = ((long) arg3); + callArgs_3[0] = ((long) arg2); + long[] callResult_3 = instance.getMachine().call(1856, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_6; + } + arg0 = memory.readInt((int) 0 < 0 ? 0 : 0 + 61628); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(0) != 0) { + break label_7; + } + instance.getMachine().call(16, new long[0]); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 26516); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) 290); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 658184)); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local4); + callArgs_5[1] = ((long) 32330); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1847, callArgs_5); + local5 = 1; + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) + arg3)); + } + local5 = 0; + } + instance.global(0).setValue(((long) (local4 + 32))); + return local5; + } + + public static long[] call_237(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_237(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_238(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + local5 = 1; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)) != 0) { + break label_1; + } + local5 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_1; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) 307); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 26516); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local4); + callArgs_0[1] = ((long) 38812); + callArgs_0[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + long[] callResult_0 = instance.getMachine().call(1847, callArgs_0); + local5 = 1; + } + instance.global(0).setValue(((long) (local4 + 16))); + return local5; + } + + public static long[] call_238(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_238(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_239(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)) != 0) { + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) 316); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 26516); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 38762); + callArgs_0[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + long[] callResult_0 = instance.getMachine().call(1847, callArgs_0); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 1; + } + + public static long[] call_239(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_239(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_240(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 28); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local0 = ((int) callResult_0[0]); + memory.writeI32((int) local0 < 0 ? local0 : local0 + 12, (int) 0); + memory.writeLong((int) local0 < 0 ? local0 : local0 + 4, (long) 0L); + memory.writeByte((int) local0 < 0 ? local0 : local0 + 24, (byte) (0)); + memory.writeI32((int) local0 < 0 ? local0 : local0 + 20, (int) 0); + memory.writeI32((int) local0 < 0 ? local0 : local0 + 16, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 61636)); + memory.writeI32((int) local0 < 0 ? local0 : local0 + 0, (int) 41916); + return local0; + } + + public static long[] call_240(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int result = Wat2WasmMachine.func_240(memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_241(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 28); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local0 = ((int) callResult_0[0]); + memory.writeI32((int) local0 < 0 ? local0 : local0 + 12, (int) 0); + memory.writeLong((int) local0 < 0 ? local0 : local0 + 4, (long) 0L); + memory.writeByte((int) local0 < 0 ? local0 : local0 + 24, (byte) (0)); + memory.writeI32((int) local0 < 0 ? local0 : local0 + 20, (int) 0); + memory.writeI32((int) local0 < 0 ? local0 : local0 + 16, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + memory.writeI32((int) local0 < 0 ? local0 : local0 + 0, (int) 41916); + return local0; + } + + public static long[] call_241(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int result = Wat2WasmMachine.func_241(memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_242(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 41884); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) 0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_1); + } + return arg0; + } + + public static long[] call_242(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_242(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_243(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 41884); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) 0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_243(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_243(arg0, memory, instance); + return null; + } + + public static void func_244(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return; + } + + public static long[] call_244(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_244(arg0, memory, instance); + return null; + } + + public static int func_245(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) 0); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg1); + label_1: { + label_2: { + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, arg1) != 0) { + break label_2; + } + local5 = (arg1 - local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local5, -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (arg1 + ((local5 >> 3) << 3))); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + label_3: { + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, local5) != 0) { + break label_3; + } + label_4: while (true) { + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + arg1 = (arg1 + 8); + local5 = (local5 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 16, (long) 0L); + memory.writeI32((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0, (int) 0); + label_5: { + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + local5 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, arg1) != 0) { + break label_5; + } + local5 = (arg1 - local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local5, -1) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) (arg1 + ((local5 >> 3) << 3))); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) arg1); + label_6: { + local5 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + arg2 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, local5) != 0) { + break label_6; + } + label_7: while (true) { + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + arg1 = (arg1 + 8); + local5 = (local5 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg1); + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 32, (byte) (0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 28, (int) arg4); + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_245(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_245(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_246(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 144); + local4 = local3; + instance.global(0).setValue(((long) local3)); + label_1: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 8) & 0xFF) != 0) { + break label_1; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 140, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 136, (int) arg2); + local5 = local4; + label_2: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 128); + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg2 = (((int) callResult_0[0]) + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 129) != 0) { + break label_2; + } + local5 = (local3 - ((arg2 + 15) & -16)); + instance.global(0).setValue(((long) local5)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 136)); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1875, callArgs_1); + } + int ciTableIdx_2 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(3))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local5); + callArgs_2[0] = ((long) arg0); + ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + } + instance.global(0).setValue(((long) (local4 + 144))); + return; + } + + public static long[] call_246(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_246(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_247(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0) - local4), 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, arg1) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) (local5 + -1)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 16)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 0); + break label_2; + } + local4 = (local4 + ((local5 + (arg1 ^ -1)) * 36)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local5 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(8, memory.readInt((int) local4 < 0 ? local4 : local4 + 0)) != 0) { + break label_1; + } + memory.writeI32((int) ((local3 + 48) + 8) < 0 ? ((local3 + 48) + 8) : ((local3 + 48) + 8) + 0, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + label_4: { + label_5: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local6) != 0) { + break label_5; + } + local4 = 0; + local5 = 0; + break label_4; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - local4), 36); + local5 = -1; + local8 = 0; + label_6: while (true) { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, memory.readInt((int) (local4 + ((local7 + local5) * 36)) < 0 ? (local4 + ((local7 + local5) * 36)) : (local4 + ((local7 + local5) * 36)) + 0)) != 0) { + break label_7; + } + label_8: { + local4 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 59) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 52) : local4)) != 0) { + break label_8; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 31370); + callArgs_1[0] = ((long) (local3 + 48)); + long[] callResult_1 = instance.getMachine().call(1662, callArgs_1); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local8); + callArgs_2[0] = ((long) (local3 + 32)); + instance.getMachine().call(1668, callArgs_2); + local4 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 43) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local7 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 36) : local4)); + callArgs_3[1] = ((long) (local7 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 32) : (local3 + 32))); + callArgs_3[0] = ((long) (local3 + 48)); + long[] callResult_3 = instance.getMachine().call(1652, callArgs_3); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), -1) != 0) { + break label_9; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + instance.getMachine().call(1777, callArgs_4); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + } + local5 = (local5 + -1); + local8 = (local8 + 1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - local4), 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, local7) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 52); + local5 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 59) & 0xFF); + } + label_10: { + label_11: { + _snap_0 = local5; + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local5); + if ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, 0) != 0 ? local4 : (_snap_0 & 255)) != 0) { + break label_11; + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 0); + callArgs_5[1] = ((long) 13973); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_5); + break label_10; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 48) : (local3 + 48))); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local3); + callArgs_6[1] = ((long) 30226); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_6); + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 59), -1) != 0) { + break label_2; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + instance.getMachine().call(1777, callArgs_7); + } + local5 = 1; + } + instance.global(0).setValue(((long) (local3 + 64))); + return local5; + } + + public static long[] call_247(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_247(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_248(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(((local2 - local3) >> 3), arg1) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + local2 = (arg1 << 3); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + local3 = (((int) callResult_0[0]) + local2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + return; + } + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = ((local3 - local4) >> 3); + local6 = (local5 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 536870912) != 0) { + break label_4; + } + local7 = 0; + label_5: { + local2 = (local2 - local4); + local8 = (local2 >>> 2); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6) : 536870911); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 536870912) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local6 << 3)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + } + local2 = (local7 + (local5 << 3)); + arg1 = (arg1 << 3); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + arg1 = (((int) callResult_2[0]) + arg1); + local7 = (local7 + (local6 << 3)); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_6; + } + label_7: while (true) { + local2 = (local2 + -8); + local3 = (local3 + -8); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_8; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_248(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_248(arg0, arg1, memory, instance); + return null; + } + + public static void func_249(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local5), 36); + local7 = (local6 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 119304648) != 0) { + break label_4; + } + label_5: { + label_6: { + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local5), 36); + local8 = (local5 << 1); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local7) != 0 ? local8 : local7) : 119304647); + if (local7 != 0) { + break label_6; + } + local5 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 119304648) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local7 * 36)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local5 = ((int) callResult_0[0]); + } + local9 = (local5 + (local7 * 36)); + local8 = (local5 + (local6 * 36)); + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0)); + callArgs_1[3] = ((long) arg3); + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_1[0] = ((long) local8); + long[] callResult_1 = instance.getMachine().call(245, callArgs_1); + local7 = ((int) callResult_1[0]); + local10 = (local7 + 36); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local11, arg3) != 0) { + break label_2; + } + arg4 = 0; + label_7: while (true) { + local7 = (local8 + arg4); + arg2 = (local7 + -32); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 0); + arg1 = (local7 + -28); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + local5 = (arg3 + arg4); + local6 = (local5 + -32); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) (local5 + -28) < 0 ? (local5 + -28) : (local5 + -28) + 0)); + memory.writeI32((int) (local7 + -36) < 0 ? (local7 + -36) : (local7 + -36) + 0, (int) memory.readInt((int) (local5 + -36) < 0 ? (local5 + -36) : (local5 + -36) + 0)); + arg2 = (local5 + -24); + memory.writeI32((int) (local7 + -24) < 0 ? (local7 + -24) : (local7 + -24) + 0, (int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 0); + arg2 = (local7 + -20); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + arg1 = (local7 + -12); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + local6 = (local5 + -20); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + arg2 = (local5 + -12); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (local7 + -8); + local5 = (local5 + -8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeByte((int) (local7 + 4) < 0 ? (local7 + 4) : (local7 + 4) + 0, (byte) (((int) memory.read((int) (local5 + 4) < 0 ? (local5 + 4) : (local5 + 4) + 0) & 0xFF))); + arg4 = (arg4 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, (arg3 + arg4)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local9); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local10); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local8 + arg4)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg3, local7) != 0) { + break label_1; + } + local7 = (local7 + -32); + label_8: while (true) { + label_9: { + local5 = memory.readInt((int) (local7 + 12) < 0 ? (local7 + 12) : (local7 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_9; + } + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) local5); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_2); + } + label_10: { + local5 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_10; + } + memory.writeI32((int) (local7 + 4) < 0 ? (local7 + 4) : (local7 + 4) + 0, (int) local5); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_3); + } + local5 = (local7 + -4); + local7 = (local7 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg3, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_11; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg3); + instance.getMachine().call(1777, callArgs_6); + } + return; + } + + public static long[] call_249(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_249(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static int func_250(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = 0; + label_1: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local3) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local4) != 0) { + break label_2; + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4), memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local4); + } + return local2; + } + + public static long[] call_250(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_250(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_251(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_2; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local4 = 1; + break label_1; + } + label_3: { + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 36) + -1); + local3 = memory.readInt((int) (local4 + (local5 * 36)) < 0 ? (local4 + (local5 * 36)) : (local4 + (local5 * 36)) + 28); + local6 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local8 = ((local6 - local7) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((local3 + arg1), local8) != 0) { + break label_3; + } + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local3, local8) != 0) { + break label_5; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 - local8)); + callArgs_1[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_1); + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local8) != 0) { + break label_4; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local7 + (local3 << 3))); + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (local4 + (local5 * 36)) < 0 ? (local4 + (local5 * 36)) : (local4 + (local5 * 36)) + 32) & 0xFF)); + break label_1; + } + label_6: { + if (arg1 != 0) { + break label_6; + } + local4 = 0; + break label_1; + } + local4 = 0; + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) local6); + callArgs_2[0] = ((long) (local6 - (arg1 << 3))); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) ((int) callResult_2[0])); + } + instance.global(0).setValue(((long) (local2 + 16))); + return local4; + } + + public static long[] call_251(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_251(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_252(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-64, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0) { + break label_3; + } + label_4: { + local2 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0), local2) != 0) { + break label_4; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local2 + 8)); + return; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local4 = (local2 - local3); + local5 = (local4 >> 3); + local6 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 536870912) != 0) { + break label_2; + } + label_5: { + label_6: { + local7 = (local4 >>> 2); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, local6) != 0 ? local7 : local6) : 536870911); + if (local6 != 0) { + break label_6; + } + local7 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 536870912) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local6 << 3)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local7 = ((int) callResult_0[0]); + } + local4 = (local7 + (local5 << 3)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + arg1 = (local7 + (local6 << 3)); + local6 = (local4 + 8); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_7; + } + label_8: while (true) { + local4 = (local4 + -8); + local2 = (local2 + -8); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_252(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_252(arg0, arg1, memory, instance); + return null; + } + + public static void func_253(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_1 = 0; + int _snap_0 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + long local12 = 0L; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local5 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + label_4: { + label_5: { + local6 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local6) != 0) { + break label_5; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 32, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local5 + 32)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local6 = 0; + break label_4; + } + local6 = memory.readInt((int) (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - arg1), 36) * 36) + arg1) + -8) < 0 ? (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - arg1), 36) * 36) + arg1) + -8) : (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - arg1), 36) * 36) + arg1) + -8) + 0); + } + arg1 = 0; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 88, (int) 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 80, (long) 0L); + label_6: { + local7 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + local8 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local7) != 0 ? 4 : ((local7 - local8) >> 3)); + local10 = (((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)) >> 3) - local6); + local11 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, local10) != 0 ? local9 : local10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_6; + } + local8 = 0; + label_7: while (true) { + label_8: { + label_9: { + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local7) != 0) { + break label_9; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 16, (long) -4294967296L); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) 30367); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_1); + break label_8; + } + local12 = -4294967296L; + _snap_0 = local6; + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + _snap_1 = local7; + local7 = ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) - local6) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(((local11 + (local8 ^ -1)) + memory.readInt((int) (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((_snap_1 - _snap_0), 36) * 36) + _snap_0) + -8) < 0 ? (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((_snap_1 - _snap_0), 36) * 36) + _snap_0) + -8) : (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((_snap_1 - _snap_0), 36) * 36) + _snap_0) + -8) + 0)), local7) != 0) { + break label_8; + } + local12 = memory.readLong((int) (local6 + (((local8 - local11) + local7) << 3)) < 0 ? (local6 + (((local8 - local11) + local7) << 3)) : (local6 + (((local8 - local11) + local7) << 3)) + 0); + } + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local5 < 0 ? local5 : local5 + 88), arg1) != 0) { + break label_11; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local12); + arg1 = (arg1 + 8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 84, (int) arg1); + break label_10; + } + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 80); + local6 = (arg1 - local7); + local13 = (local6 >> 3); + local14 = (local13 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local14, 536870912) != 0) { + break label_2; + } + label_12: { + label_13: { + local15 = (local6 >>> 2); + local14 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local15, local14) != 0 ? local15 : local14) : 536870911); + if (local14 != 0) { + break label_13; + } + local15 = 0; + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local14, 536870912) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local14 << 3)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local15 = ((int) callResult_2[0]); + } + local6 = (local15 + (local13 << 3)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local12); + local15 = (local15 + (local14 << 3)); + local14 = (local6 + 8); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, arg1) != 0) { + break label_14; + } + label_15: while (true) { + local6 = (local6 + -8); + arg1 = (arg1 + -8); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_15; + } + break; + } + arg1 = memory.readInt((int) local5 < 0 ? local5 : local5 + 80); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 88, (int) local15); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 84, (int) local14); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 80, (int) local6); + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_16; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_3); + } + arg1 = local14; + } + local8 = (local8 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, local8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 32); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg1 = ((int) callResult_4[0]); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 17, (byte) (0)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 31065)); + memory.writeLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 31073)); + memory.writeByte((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 31081) & 0xFF))); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 64, (int) arg1); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 68, (long) -9223371899415822319L); + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_17; + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 24); + callArgs_5[1] = ((long) 31083); + callArgs_5[0] = ((long) (local5 + 64)); + long[] callResult_5 = instance.getMachine().call(1649, callArgs_5); + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) arg2); + callArgs_6[0] = ((long) (local5 + 64)); + long[] callResult_6 = instance.getMachine().call(1662, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 31108); + callArgs_7[0] = ((long) (local5 + 64)); + long[] callResult_7 = instance.getMachine().call(1662, callArgs_7); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 0); + callArgs_8[1] = ((long) arg3); + callArgs_8[0] = ((long) (local5 + 48)); + instance.getMachine().call(254, callArgs_8); + arg1 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 59) & 0xFF); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 52) : arg1)); + callArgs_9[1] = ((long) (local6 != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 48) : (local5 + 48))); + callArgs_9[0] = ((long) (local5 + 64)); + long[] callResult_9 = instance.getMachine().call(1652, callArgs_9); + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 59), -1) != 0) { + break label_18; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 48)); + instance.getMachine().call(1777, callArgs_10); + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 31050); + callArgs_11[0] = ((long) (local5 + 64)); + long[] callResult_11 = instance.getMachine().call(1662, callArgs_11); + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local10, local9) != 0 ? 31365 : 0)); + callArgs_12[1] = ((long) (local5 + 80)); + callArgs_12[0] = ((long) (local5 + 48)); + instance.getMachine().call(254, callArgs_12); + arg1 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 59) & 0xFF); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0); + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) (local6 != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 52) : arg1)); + callArgs_13[1] = ((long) (local6 != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 48) : (local5 + 48))); + callArgs_13[0] = ((long) (local5 + 64)); + long[] callResult_13 = instance.getMachine().call(1652, callArgs_13); + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 59), -1) != 0) { + break label_19; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 48)); + instance.getMachine().call(1777, callArgs_14); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 75), 0) != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 64) : (local5 + 64))); + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) local5); + callArgs_15[1] = ((long) 11317); + callArgs_15[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_15); + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 75), -1) != 0) { + break label_20; + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 64)); + instance.getMachine().call(1777, callArgs_16); + } + arg1 = memory.readInt((int) local5 < 0 ? local5 : local5 + 80); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_17); + } + instance.global(0).setValue(((long) (local5 + 96))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_253(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_253(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static void func_254(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeShort((int) arg0 < 0 ? arg0 : arg0 + 0, (short) (91)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1662, callArgs_0); + } + label_2: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)) != 0) { + break label_2; + } + arg2 = 0; + local5 = 0; + label_3: while (true) { + label_4: { + label_5: { + local4 = (local4 + arg2); + local6 = memory.readLong((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local6, -4294967296L) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(4294967275L, (local6 & 4294967295L)) != 0) { + break label_5; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 17537); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1662, callArgs_1); + break label_4; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(38, callArgs_2); + local4 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 11) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local7 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 4) : local4)); + callArgs_3[1] = ((long) (local7 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : local3)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1652, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), -1) != 0) { + break label_4; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_4); + } + label_6: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local7 = ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - local4) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, (local7 + -1)) != 0) { + break label_6; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 31370); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1662, callArgs_5); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local7 = ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - local4) >> 3); + } + arg2 = (arg2 + 8); + local5 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local7) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 26819); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1662, callArgs_6); + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_254(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_254(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_255(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + long local14 = 0L; + int local15 = 0; + long local16 = 0L; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = 0; + label_1: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local5) != 0) { + break label_1; + } + local7 = ((local5 - local6) >> 3); + local8 = 0; + local9 = -1; + local10 = 0; + local4 = 0; + label_2: while (true) { + label_3: { + label_4: { + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local12 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local12, local11) != 0) { + break label_4; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local12 = 1; + break label_3; + } + label_5: { + local12 = (local12 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local11 - local12), 36) + -1) * 36)); + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local13 = ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) - local11) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((local9 + (local7 + memory.readInt((int) local12 < 0 ? local12 : local12 + 28))), local13) != 0) { + break label_5; + } + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local12 < 0 ? local12 : local12 + 32) & 0xFF)); + break label_3; + } + local12 = 0; + local14 = memory.readLong((int) (local6 + local8) < 0 ? (local6 + local8) : (local6 + local8) + 0); + local15 = (int) local14; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_3; + } + local16 = memory.readLong((int) (local11 + ((local10 + (local13 - local7)) << 3)) < 0 ? (local11 + ((local10 + (local13 - local7)) << 3)) : (local11 + ((local10 + (local13 - local7)) << 3)) + 0); + local7 = (int) local16; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_3; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local15) != 0) { + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local7) != 0) { + break label_6; + } + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((int) (local14 >>> 32L), (int) (local16 >>> 32L)); + break label_3; + } + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local15, local7); + } + local8 = (local8 + 8); + local9 = (local9 + -1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | local12); + local10 = (local10 + 1); + local7 = ((local5 - local6) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, local7) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) arg1); + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(253, callArgs_1); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_255(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_255(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_256(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + int local11 = 0; + long local12 = 0L; + int local13 = 0; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local7 = ((local5 - local6) >> 3); + local8 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) - local8) >> 3), local7) != 0) { + break label_2; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local5) != 0) { + break label_3; + } + local7 = 0; + break label_1; + } + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, 1) != 0 ? local7 : 1); + local5 = 0; + label_4: while (true) { + local7 = 0; + label_5: { + local10 = memory.readLong((int) local8 < 0 ? local8 : local8 + 0); + local11 = (int) local10; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_5; + } + local7 = 0; + local12 = memory.readLong((int) local6 < 0 ? local6 : local6 + 0); + local13 = (int) local12; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local13) != 0) { + break label_5; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local11) != 0) { + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local13) != 0) { + break label_6; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((int) (local12 >>> 32L), (int) (local10 >>> 32L)); + break label_5; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, local13); + } + local6 = (local6 + 8); + local8 = (local8 + 8); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | local7); + local9 = (local9 + -1); + if (local9 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local7 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (local4 + 32)); + instance.getMachine().call(254, callArgs_0); + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 32); + local8 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 43); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 0); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local4 + 16)); + instance.getMachine().call(254, callArgs_1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0) != 0 ? local7 : (local4 + 32))); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 27), 0) != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 16) : (local4 + 16))); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) 10604); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_2); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 27), -1) != 0) { + break label_7; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 16)); + instance.getMachine().call(1777, callArgs_3); + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 43), -1) != 0) { + break label_8; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 32)); + instance.getMachine().call(1777, callArgs_4); + } + local7 = 1; + } + instance.global(0).setValue(((long) (local4 + 48))); + return local7; + } + + public static long[] call_256(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_256(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_257(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local5) != 0) { + break label_3; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 16)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + break label_2; + } + label_4: { + local6 = (arg1 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - arg1), 36) + -1) * 36)); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local8 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local7) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(memory.readInt((int) local6 < 0 ? local6 : local6 + 28), local8) != 0) { + break label_4; + } + local9 = 0; + local6 = (int) local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + local10 = memory.readLong((int) (((local8 << 3) + local7) + -8) < 0 ? (((local8 << 3) + local7) + -8) : (((local8 << 3) + local7) + -8) + 0); + local7 = (int) local10; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_1; + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local6) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local7) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((int) (local4 >>> 32L), (int) (local10 >>> 32L)) != 0) { + break label_2; + } + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local7) != 0) { + break label_2; + } + break label_1; + } + local9 = 0; + if (((int) memory.read((int) local6 < 0 ? local6 : local6 + 32) & 0xFF) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 8); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) arg1); + local5 = (arg1 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local5); + local9 = 1; + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) 0); + callArgs_2[3] = ((long) (local3 + 32)); + callArgs_2[2] = ((long) arg2); + callArgs_2[1] = ((long) 1); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(253, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_3); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + } + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local5) != 0) { + break label_7; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) -4294967296L); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local3); + callArgs_4[1] = ((long) 30367); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_4); + arg1 = 1; + break label_6; + } + label_8: { + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - arg1), 36) + -1); + local5 = memory.readInt((int) (arg1 + (local7 * 36)) < 0 ? (arg1 + (local7 * 36)) : (arg1 + (local7 * 36)) + 28); + arg2 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local6 = ((arg2 - local8) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((local5 + 1), local6) != 0) { + break label_8; + } + label_9: { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local5, local6) != 0) { + break label_10; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local5 - local6)); + callArgs_5[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_5); + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local6) != 0) { + break label_9; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local8 + (local5 << 3))); + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (arg1 + (local7 * 36)) < 0 ? (arg1 + (local7 * 36)) : (arg1 + (local7 * 36)) + 32) & 0xFF)); + break label_6; + } + arg1 = 0; + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 0); + callArgs_6[1] = ((long) arg2); + callArgs_6[0] = ((long) (arg2 + -8)); + long[] callResult_6 = instance.getMachine().call(1891, callArgs_6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) ((int) callResult_6[0])); + } + instance.global(0).setValue(((long) (local3 + 48))); + return (local9 | arg1); + } + + public static long[] call_257(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_257(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_258(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + long local5 = 0L; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + long local11 = 0L; + long local12 = 0L; + local4 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local4)); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + label_1: { + label_2: { + local6 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, local6) != 0) { + break label_2; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 32, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local4 + 32)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local7 = 1; + break label_1; + } + label_3: { + local7 = (arg2 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - arg2), 36) + -1) * 36)); + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local9 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local8) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(memory.readInt((int) local7 < 0 ? local7 : local7 + 28), local9) != 0) { + break label_3; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local7 < 0 ? local7 : local7 + 32) & 0xFF)); + break label_1; + } + local7 = 0; + local10 = (int) local5; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_1; + } + local11 = memory.readLong((int) (((local9 << 3) + local8) + -8) < 0 ? (((local9 << 3) + local8) + -8) : (((local9 << 3) + local8) + -8) + 0); + local8 = (int) local11; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_1; + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local10) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local8) != 0) { + break label_4; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((int) (local5 >>> 32L), (int) (local11 >>> 32L)); + break label_1; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local10, local8); + } + local11 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, local6) != 0) { + break label_7; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) -4294967296L); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local4 + 16)); + callArgs_1[1] = ((long) 30367); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_1); + break label_6; + } + label_8: { + label_9: { + arg1 = (arg2 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - arg2), 36) + -1) * 36)); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local10 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local9) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 28) + 1), local10) != 0) { + break label_9; + } + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 32) & 0xFF)); + break label_8; + } + local8 = 0; + arg1 = (int) local11; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_8; + } + local12 = memory.readLong((int) (((local10 << 3) + local9) + -16) < 0 ? (((local10 << 3) + local9) + -16) : (((local10 << 3) + local9) + -16) + 0); + local9 = (int) local12; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_8; + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, arg1) != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local9) != 0) { + break label_10; + } + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((int) (local11 >>> 32L), (int) (local12 >>> 32L)); + break label_8; + } + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local9); + } + arg1 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, (local7 | local8)) != 0) { + break label_5; + } + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 16); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 8, (long) local5); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) local11); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 48, (int) arg2); + local6 = (arg2 + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 56, (int) local6); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 52, (int) local6); + arg1 = 1; + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) (local4 + 48)); + callArgs_3[2] = ((long) arg3); + callArgs_3[1] = ((long) 1); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(253, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_4); + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + } + label_11: { + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, local6) != 0) { + break label_12; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) -4294967296L); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local4); + callArgs_5[1] = ((long) 30367); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_5); + arg2 = 1; + break label_11; + } + label_13: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - arg2), 36) + -1); + local6 = memory.readInt((int) (arg2 + (local8 * 36)) < 0 ? (arg2 + (local8 * 36)) : (arg2 + (local8 * 36)) + 28); + local7 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + arg3 = ((local7 - local9) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((local6 + 2), arg3) != 0) { + break label_13; + } + label_14: { + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local6, arg3) != 0) { + break label_15; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local6 - arg3)); + callArgs_6[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_6); + break label_14; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, arg3) != 0) { + break label_14; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local9 + (local6 << 3))); + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (arg2 + (local8 * 36)) < 0 ? (arg2 + (local8 * 36)) : (arg2 + (local8 * 36)) + 32) & 0xFF)); + break label_11; + } + arg2 = 0; + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) local7); + callArgs_7[0] = ((long) (local7 + -16)); + long[] callResult_7 = instance.getMachine().call(1891, callArgs_7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) ((int) callResult_7[0])); + } + instance.global(0).setValue(((long) (local4 + 64))); + return (arg1 | arg2); + } + + public static long[] call_258(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_258(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_259(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + long local6 = 0L; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + long local12 = 0L; + long local13 = 0L; + long local14 = 0L; + local5 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local5)); + local6 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + label_1: { + label_2: { + local7 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg3, local7) != 0) { + break label_2; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 48, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local5 + 48)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local8 = 1; + break label_1; + } + label_3: { + local8 = (arg3 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local7 - arg3), 36) + -1) * 36)); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local10 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local9) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(memory.readInt((int) local8 < 0 ? local8 : local8 + 28), local10) != 0) { + break label_3; + } + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local8 < 0 ? local8 : local8 + 32) & 0xFF)); + break label_1; + } + local8 = 0; + local11 = (int) local6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_1; + } + local12 = memory.readLong((int) (((local10 << 3) + local9) + -8) < 0 ? (((local10 << 3) + local9) + -8) : (((local10 << 3) + local9) + -8) + 0); + local9 = (int) local12; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_1; + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local11) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local9) != 0) { + break label_4; + } + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((int) (local6 >>> 32L), (int) (local12 >>> 32L)); + break label_1; + } + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, local9); + } + local12 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg3, local7) != 0) { + break label_6; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 32, (long) -4294967296L); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 32)); + callArgs_1[1] = ((long) 30367); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_1); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + arg2 = 1; + break label_5; + } + label_7: { + arg2 = (arg3 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local7 - arg3), 36) + -1) * 36)); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local10 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local9) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 28) + 1), local10) != 0) { + break label_7; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 32) & 0xFF)); + break label_5; + } + arg2 = 0; + local11 = (int) local12; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_5; + } + local13 = memory.readLong((int) (((local10 << 3) + local9) + -16) < 0 ? (((local10 << 3) + local9) + -16) : (((local10 << 3) + local9) + -16) + 0); + local9 = (int) local13; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_5; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local11) != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local9) != 0) { + break label_8; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((int) (local12 >>> 32L), (int) (local13 >>> 32L)); + break label_5; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, local9); + } + local13 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + label_9: { + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg3, local7) != 0) { + break label_11; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 16, (long) -4294967296L); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local5 + 16)); + callArgs_2[1] = ((long) 30367); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_2); + break label_10; + } + local8 = (local8 | arg2); + label_12: { + label_13: { + arg2 = (arg3 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local7 - arg3), 36) + -1) * 36)); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local10 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local9) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 28) + 2), local10) != 0) { + break label_13; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 32) & 0xFF)); + break label_12; + } + arg1 = 0; + arg2 = (int) local13; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_12; + } + local14 = memory.readLong((int) (((local10 << 3) + local9) + -24) < 0 ? (((local10 << 3) + local9) + -24) : (((local10 << 3) + local9) + -24) + 0); + local9 = (int) local14; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_12; + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, arg2) != 0) { + break label_14; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local9) != 0) { + break label_14; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((int) (local13 >>> 32L), (int) (local14 >>> 32L)); + break label_12; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, local9); + } + arg2 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, (local8 | arg1)) != 0) { + break label_9; + } + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 24); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg3 = ((int) callResult_3[0]); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 16, (long) local6); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 8, (long) local12); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) local13); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 64, (int) arg3); + local7 = (arg3 + 24); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 72, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 68, (int) local7); + arg2 = 1; + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) 0); + callArgs_4[3] = ((long) (local5 + 64)); + callArgs_4[2] = ((long) arg4); + callArgs_4[1] = ((long) 1); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(253, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg3); + instance.getMachine().call(1777, callArgs_5); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + } + label_15: { + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg3, local7) != 0) { + break label_16; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) -4294967296L); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local5); + callArgs_6[1] = ((long) 30367); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_6); + arg3 = 1; + break label_15; + } + label_17: { + arg4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local7 - arg3), 36) + -1); + local7 = memory.readInt((int) (arg3 + (arg4 * 36)) < 0 ? (arg3 + (arg4 * 36)) : (arg3 + (arg4 * 36)) + 28); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local8 = ((arg1 - local9) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((local7 + 3), local8) != 0) { + break label_17; + } + label_18: { + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local7, local8) != 0) { + break label_19; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) (local7 - local8)); + callArgs_7[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_7); + break label_18; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, local8) != 0) { + break label_18; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local9 + (local7 << 3))); + } + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (arg3 + (arg4 * 36)) < 0 ? (arg3 + (arg4 * 36)) : (arg3 + (arg4 * 36)) + 32) & 0xFF)); + break label_15; + } + arg3 = 0; + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 0); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) (arg1 + -24)); + long[] callResult_8 = instance.getMachine().call(1891, callArgs_8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) ((int) callResult_8[0])); + } + instance.global(0).setValue(((long) (local5 + 80))); + return (arg2 | arg3); + } + + public static long[] call_259(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_259(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_260(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + long local6 = 0L; + local5 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 72, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local5 + 72)); + callArgs_0[0] = ((long) (local5 + 80)); + instance.getMachine().call(192, callArgs_0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_2; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 68, (int) -1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 64, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + break label_1; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 64, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 96)); + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local5 + 72)); + callArgs_1[0] = ((long) (local5 + 80)); + instance.getMachine().call(192, callArgs_1); + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_4; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 60, (int) -1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 56, (int) (((int) memory.read((int) arg3 < 0 ? arg3 : arg3 + 18) & 0xFF) != 0 ? -2 : -1)); + break label_3; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 56, (long) memory.readLong((int) (local5 + 104) < 0 ? (local5 + 104) : (local5 + 104) + 0)); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 72)); + callArgs_2[0] = ((long) (local5 + 80)); + instance.getMachine().call(192, callArgs_2); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_6; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 52, (int) -1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 48, (int) (((int) memory.read((int) arg4 < 0 ? arg4 : arg4 + 18) & 0xFF) != 0 ? -2 : -1)); + break label_5; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 48, (long) memory.readLong((int) (local5 + 112) < 0 ? (local5 + 112) : (local5 + 112) + 0)); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 72)); + callArgs_3[0] = ((long) (local5 + 80)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 32, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 64)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 24, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 56)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 16, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 48)); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 80)); + callArgs_4[3] = ((long) (local5 + 16)); + callArgs_4[2] = ((long) (local5 + 24)); + callArgs_4[1] = ((long) (local5 + 32)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(259, callArgs_4); + arg4 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local5 + 72)); + callArgs_5[0] = ((long) (local5 + 80)); + instance.getMachine().call(192, callArgs_5); + local6 = memory.readLong((int) local5 < 0 ? local5 : local5 + 88); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 40, (long) local6); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local6); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local5 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_6); + instance.global(0).setValue(((long) (local5 + 144))); + return arg4; + } + + public static long[] call_260(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_260(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_261(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (int) local3); + local4 = local3; + label_1: { + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local5) != 0) { + break label_1; + } + local3 = (local5 + -32); + label_2: while (true) { + label_3: { + local4 = memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local4); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_0); + } + label_4: { + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + memory.writeI32((int) (local3 + 4) < 0 ? (local3 + 4) : (local3 + 4) + 0, (int) local4); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_1); + } + local4 = (local3 + -4); + local3 = (local3 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) 0); + local3 = ((local4 - local3) >> 3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local3); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0)) != 0) { + break label_6; + } + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) local3); + callArgs_2[3] = ((long) arg1); + callArgs_2[2] = ((long) (local2 + 8)); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(245, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (((int) callResult_2[0]) + 36)); + break label_5; + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) (local2 + 24)); + callArgs_3[3] = ((long) arg1); + callArgs_3[2] = ((long) (local2 + 8)); + callArgs_3[1] = ((long) (local2 + 28)); + callArgs_3[0] = ((long) (arg0 + 28)); + instance.getMachine().call(249, callArgs_3); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_5; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_4); + } + instance.global(0).setValue(((long) (local2 + 32))); + return 0; + } + + public static long[] call_261(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_261(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_262(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 40)); + callArgs_0[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 40)); + callArgs_1[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 32)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + callArgs_2[1] = ((long) (local3 + 16)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(257, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 40)); + callArgs_3[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_3); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 56); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_4); + instance.global(0).setValue(((long) (local3 + 112))); + return arg1; + } + + public static long[] call_262(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_262(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_263(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 56)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 56)); + callArgs_1[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) memory.readLong((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 56)); + callArgs_2[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 48)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 40)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) (local3 + 24)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(258, callArgs_3); + arg1 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 56)); + callArgs_4[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_4); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 72); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 8)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_5); + instance.global(0).setValue(((long) (local3 + 128))); + return arg1; + } + + public static long[] call_263(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_263(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_264(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 56)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 56)); + callArgs_1[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) memory.readLong((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 56)); + callArgs_2[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 48)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 40)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) (local3 + 24)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(258, callArgs_3); + arg1 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 56)); + callArgs_4[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_4); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 72); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 8)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_5); + instance.global(0).setValue(((long) (local3 + 128))); + return arg1; + } + + public static long[] call_264(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_264(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_265(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 72, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 72)); + callArgs_0[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 68, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 64, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 72)); + callArgs_1[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 56, (long) memory.readLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 72)); + callArgs_2[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) memory.readLong((int) (local3 + 112) < 0 ? (local3 + 112) : (local3 + 112) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 72)); + callArgs_3[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 64)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 56)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 80)); + callArgs_4[3] = ((long) (local3 + 16)); + callArgs_4[2] = ((long) (local3 + 24)); + callArgs_4[1] = ((long) (local3 + 32)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(259, callArgs_4); + arg1 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 72)); + callArgs_5[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_5); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 88); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local3 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_6); + instance.global(0).setValue(((long) (local3 + 144))); + return arg1; + } + + public static long[] call_265(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_265(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_266(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 72, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 72)); + callArgs_0[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 68, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 64, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 72)); + callArgs_1[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 56, (long) memory.readLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 72)); + callArgs_2[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) memory.readLong((int) (local3 + 112) < 0 ? (local3 + 112) : (local3 + 112) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 72)); + callArgs_3[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 64)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 56)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 80)); + callArgs_4[3] = ((long) (local3 + 16)); + callArgs_4[2] = ((long) (local3 + 24)); + callArgs_4[1] = ((long) (local3 + 32)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(259, callArgs_4); + arg1 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 72)); + callArgs_5[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_5); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 88); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local3 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_6); + instance.global(0).setValue(((long) (local3 + 144))); + return arg1; + } + + public static long[] call_266(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_266(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_267(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_267(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_267(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_268(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 56)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 56)); + callArgs_1[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) memory.readLong((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 56)); + callArgs_2[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 48)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 40)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) (local3 + 24)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(258, callArgs_3); + arg1 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 56)); + callArgs_4[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_4); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 72); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 8)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_5); + instance.global(0).setValue(((long) (local3 + 128))); + return arg1; + } + + public static long[] call_268(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_268(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_269(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 56)); + callArgs_0[0] = ((long) (local2 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 80)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 + 56)); + callArgs_1[0] = ((long) (local2 + 64)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) memory.readLong((int) (local2 + 88) < 0 ? (local2 + 88) : (local2 + 88) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 56)); + callArgs_2[0] = ((long) (local2 + 64)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 48)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 40)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 64)); + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) (local2 + 24)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(258, callArgs_3); + arg1 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 56)); + callArgs_4[0] = ((long) (local2 + 64)); + instance.getMachine().call(192, callArgs_4); + local3 = memory.readLong((int) local2 < 0 ? local2 : local2 + 72); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local2 + 8)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_5); + instance.global(0).setValue(((long) (local2 + 128))); + return arg1; + } + + public static long[] call_269(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_269(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_270(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 14020); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(255, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(251, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) 2); + local6 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)) >> 3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local6); + label_1: { + label_2: { + local7 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0)) != 0) { + break label_2; + } + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) local6); + callArgs_2[3] = ((long) arg2); + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 2); + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(245, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (((int) callResult_2[0]) + 36)); + break label_1; + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) (local3 + 20)); + callArgs_3[3] = ((long) arg2); + callArgs_3[2] = ((long) arg1); + callArgs_3[1] = ((long) (local3 + 24)); + callArgs_3[0] = ((long) (arg0 + 28)); + instance.getMachine().call(249, callArgs_3); + } + label_3: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_3; + } + label_4: while (true) { + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local8); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_4); + arg2 = (arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + instance.global(0).setValue(((long) (local3 + 32))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)); + } + + public static long[] call_270(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_270(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_271(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0) - local3), 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, arg1) != 0) { + break label_3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (local4 + -1)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local2 + 16)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + break label_2; + } + arg1 = (local3 + ((local4 + (arg1 ^ -1)) * 36)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 11773); + callArgs_1[1] = ((long) (arg1 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(3, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0 ? 4 : 16))); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(255, callArgs_1); + arg1 = ((int) callResult_1[0]); + label_4: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_4; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1); + local4 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 36) * 36) + local4) + -36); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 32, (byte) (1)); + label_5: { + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 28); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local3 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local5) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local4, local3) != 0) { + break label_5; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 - local3)); + callArgs_2[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_2); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local3) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local5 + (local4 << 3))); + break label_1; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) -4294967296L); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 30367); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_3); + } + arg1 = 1; + } + instance.global(0).setValue(((long) (local2 + 32))); + return arg1; + } + + public static long[] call_271(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_271(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_272(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) -1L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) -1L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 14722); + callArgs_0[1] = ((long) (local2 + 24)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(257, callArgs_0); + local3 = ((int) callResult_0[0]); + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0) - local4), 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, arg1) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (local5 + -1)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) 30367); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_1); + arg1 = 1; + break label_1; + } + arg1 = (local4 + ((local5 + (arg1 ^ -1)) * 36)); + local4 = (arg1 + 4); + local6 = (arg1 + 16); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(3, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0 ? local4 : local6); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 14722); + callArgs_2[1] = ((long) local5); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(255, callArgs_2); + local7 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) ((memory.readInt((int) local5 < 0 ? local5 : local5 + 4) - memory.readInt((int) local5 < 0 ? local5 : local5 + 0)) >> 3)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(251, callArgs_3); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])); + local3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7)); + label_3: { + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(3, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0 ? local4 : local6); + arg1 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, arg1) != 0) { + break label_3; + } + label_4: while (true) { + local9 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) local9); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local9); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_4); + arg1 = (arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + arg1 = (local3 | local8); + } + instance.global(0).setValue(((long) (local2 + 48))); + return arg1; + } + + public static long[] call_272(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_272(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_273(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 40, (int) 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 8, (long) -1L); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) memory.readLong((int) local1 < 0 ? local1 : local1 + 8)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 17262); + callArgs_0[1] = ((long) local1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(257, callArgs_0); + arg0 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local1 + 16))); + return arg0; + } + + public static long[] call_273(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_273(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_274(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0) - local3), 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, arg1) != 0) { + break label_3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (local4 + -1)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local2 + 16)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + break label_2; + } + arg1 = (local3 + ((local4 + (arg1 ^ -1)) * 36)); + local4 = (arg1 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(3, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0 ? 4 : 16)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 17262); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(255, callArgs_1); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])); + label_4: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + if (local3 != 0) { + break label_4; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 40, (int) local4); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((memory.readInt((int) local4 < 0 ? local4 : local4 + 4) - memory.readInt((int) local4 < 0 ? local4 : local4 + 0)), (memory.readInt((int) local3 < 0 ? local3 : local3 + 4) - memory.readInt((int) local3 < 0 ? local3 : local3 + 0))) != 0) { + break label_1; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) (local2 + 48)); + instance.getMachine().call(254, callArgs_2); + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 48); + local3 = (int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 59); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (local2 + 32)); + instance.getMachine().call(254, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0 ? arg1 : (local2 + 48))); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 32) : (local2 + 32))); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local2); + callArgs_4[1] = ((long) 10543); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_4); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), -1) != 0) { + break label_5; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + instance.getMachine().call(1777, callArgs_5); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 59), -1) != 0) { + break label_2; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 48)); + instance.getMachine().call(1777, callArgs_6); + } + arg1 = 1; + } + instance.global(0).setValue(((long) (local2 + 64))); + return arg1; + } + + public static long[] call_274(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_274(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_275(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + local2 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_2; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local1); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local3 = 1; + break label_1; + } + local3 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 36) * 36) + local3) + -36); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 32, (byte) (1)); + label_3: { + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 28); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local5 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local4) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local2, local5) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 - local5)); + callArgs_1[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_1); + local3 = 0; + break label_1; + } + local3 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, local5) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local4 + (local2 << 3))); + } + instance.global(0).setValue(((long) (local1 + 16))); + return local3; + } + + public static long[] call_275(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_275(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_276(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 13308); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(255, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(251, callArgs_1); + local5 = ((int) callResult_1[0]); + label_1: { + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg1) != 0) { + break label_1; + } + label_2: while (true) { + local6 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local6); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) local6); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_2); + arg1 = (arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + instance.global(0).setValue(((long) (local3 + 16))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)); + } + + public static long[] call_276(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_276(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_277(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local4 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) -1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) (((int) memory.read((int) arg3 < 0 ? arg3 : arg3 + 18) & 0xFF) != 0 ? -2 : -1)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 16)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 7378); + callArgs_0[1] = ((long) (local4 + 8)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(257, callArgs_0); + arg3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 7378); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(255, callArgs_1); + local5 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(251, callArgs_2); + local6 = ((int) callResult_2[0]); + label_1: { + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg1) != 0) { + break label_1; + } + label_2: while (true) { + local7 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) local7); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) local7); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_3); + arg1 = (arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + instance.global(0).setValue(((long) (local4 + 32))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6)); + } + + public static long[] call_277(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_277(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_278(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_2; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local2 + 16)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local3 = 1; + break label_1; + } + label_3: { + label_4: { + local4 = (local4 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 36) + -1) * 36)); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local6 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local5) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(memory.readInt((int) local4 < 0 ? local4 : local4 + 28), local6) != 0) { + break label_4; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 32) & 0xFF)); + break label_3; + } + local3 = 0; + local7 = memory.readLong((int) (((local6 << 3) + local5) + -8) < 0 ? (((local6 << 3) + local5) + -8) : (((local6 << 3) + local5) + -8) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, (int) local7) != 0) { + break label_3; + } + local4 = (int) (local7 >>> 32L); + break label_1; + } + local4 = -1; + } + local7 = ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local4) << 32L) | 4294967275L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local7); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local7); + label_5: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 14847); + callArgs_1[1] = ((long) (local2 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(257, callArgs_1); + arg0 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0]))); + if (arg0 != 0) { + break label_5; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local4); + } + instance.global(0).setValue(((long) (local2 + 32))); + return arg0; + } + + public static long[] call_278(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_278(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_279(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 13284); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(255, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(251, callArgs_1); + local5 = ((int) callResult_1[0]); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0)) != 0) { + break label_3; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) -1L); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 30367); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_2); + break label_2; + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg0); + callArgs_3[2] = ((long) (arg1 + 16)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(256, callArgs_3); + arg1 = ((int) callResult_3[0]); + label_4: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, local6) != 0) { + break label_4; + } + arg1 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)); + arg2 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - arg2), 36) * 36) + arg2) + -36); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 32, (byte) (1)); + label_5: { + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 28); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local4 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local5) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg2, local4) != 0) { + break label_5; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (arg2 - local4)); + callArgs_4[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_4); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, local4) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local5 + (arg2 << 3))); + break label_1; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) -4294967296L); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local3 + 16)); + callArgs_5[1] = ((long) 30367); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_5); + } + arg1 = 1; + } + instance.global(0).setValue(((long) (local3 + 32))); + return arg1; + } + + public static long[] call_279(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_279(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_280(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) -1L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) -1L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 7371); + callArgs_0[1] = ((long) (local3 + 32)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(257, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 7371); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(255, callArgs_1); + local5 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(251, callArgs_2); + local6 = ((int) callResult_2[0]); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0)) != 0) { + break label_3; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) -1L); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local3); + callArgs_3[1] = ((long) 30367); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_3); + break label_2; + } + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) arg0); + callArgs_4[2] = ((long) (arg1 + 16)); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(256, callArgs_4); + arg1 = ((int) callResult_4[0]); + label_4: { + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, local7) != 0) { + break label_4; + } + arg1 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)); + arg2 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local7 - arg2), 36) * 36) + arg2) + -36); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 32, (byte) (1)); + label_5: { + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 28); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local4 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local5) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg2, local4) != 0) { + break label_5; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (arg2 - local4)); + callArgs_5[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_5); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, local4) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local5 + (arg2 << 3))); + break label_1; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) -4294967296L); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) (local3 + 16)); + callArgs_6[1] = ((long) 30367); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_6); + } + arg1 = 1; + } + instance.global(0).setValue(((long) (local3 + 48))); + return arg1; + } + + public static long[] call_280(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_280(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_281(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 56)); + callArgs_0[0] = ((long) (local2 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 80)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 + 56)); + callArgs_1[0] = ((long) (local2 + 64)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) memory.readLong((int) (local2 + 88) < 0 ? (local2 + 88) : (local2 + 88) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 56)); + callArgs_2[0] = ((long) (local2 + 64)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 48)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 40)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 64)); + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) (local2 + 24)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(258, callArgs_3); + arg1 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 56)); + callArgs_4[0] = ((long) (local2 + 64)); + instance.getMachine().call(192, callArgs_4); + local3 = memory.readLong((int) local2 < 0 ? local2 : local2 + 72); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local2 + 8)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_5); + instance.global(0).setValue(((long) (local2 + 128))); + return arg1; + } + + public static long[] call_281(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_281(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_282(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + long local12 = 0L; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_2; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local4 = 1; + break label_1; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 36) + -1); + local3 = (local4 + (local5 * 36)); + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(6, local6) & com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, local6)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 13952); + callArgs_1[1] = ((long) (local3 + 16)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(255, callArgs_1); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) ((memory.readInt((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0) - memory.readInt((int) local3 < 0 ? local3 : local3 + 16)) >> 3)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(251, callArgs_2); + local9 = ((int) callResult_2[0]); + label_3: { + label_4: { + local10 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local10) != 0) { + break label_4; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) -4294967296L); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) 30367); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_3); + local10 = 1; + break label_3; + } + local6 = memory.readInt((int) (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local10 - local6), 36) * 36) + local6) + -8) < 0 ? (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local10 - local6), 36) * 36) + local6) + -8) : (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local10 - local6), 36) * 36) + local6) + -8) + 0); + local10 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) 0L); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((local10 - local11) >> 3), local6); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) 1); + callArgs_4[3] = ((long) (local2 + 32)); + callArgs_4[2] = ((long) 13952); + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(253, callArgs_4); + } + local7 = (local7 | local8); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local9); + label_5: { + label_6: { + local6 = memory.readInt((int) (local4 + (local5 * 36)) < 0 ? (local4 + (local5 * 36)) : (local4 + (local5 * 36)) + 28); + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local9 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local11) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local6, local9) != 0) { + break label_6; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 - local9)); + callArgs_5[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_5); + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local9) != 0) { + break label_5; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local11 + (local6 << 3))); + } + local6 = (local7 | local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 8); + memory.writeByte((int) (local4 + (local5 * 36)) < 0 ? (local4 + (local5 * 36)) : (local4 + (local5 * 36)) + 32, (byte) (0)); + label_7: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_7; + } + label_8: while (true) { + local12 = memory.readLong((int) local4 < 0 ? local4 : local4 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) local12); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local12); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local2 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_6); + local4 = (local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + local4 = (local6 | local10); + } + instance.global(0).setValue(((long) (local2 + 48))); + return local4; + } + + public static long[] call_282(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_282(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_283(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_0); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_283(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_283(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_284(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 40)); + callArgs_0[0] = ((long) (local2 + 48)); + instance.getMachine().call(192, callArgs_0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 + 40)); + callArgs_1[0] = ((long) (local2 + 48)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 32)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 48)); + callArgs_2[1] = ((long) (local2 + 16)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(257, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 40)); + callArgs_3[0] = ((long) (local2 + 48)); + instance.getMachine().call(192, callArgs_3); + local3 = memory.readLong((int) local2 < 0 ? local2 : local2 + 56); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_4); + instance.global(0).setValue(((long) (local2 + 112))); + return arg1; + } + + public static long[] call_284(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_284(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_285(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + long local12 = 0L; + local2 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + label_2: { + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local5), 36); + arg1 = (arg1 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, arg1) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) (local6 + -1)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local2 + 32)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + break label_1; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local4) != 0) { + break label_3; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) -4294967296L); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) 30367); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_1); + break label_1; + } + arg1 = (local6 + -1); + local3 = (local5 + (arg1 * 36)); + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local4 = (local3 + 16); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 13952); + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(255, callArgs_2); + local7 = ((int) callResult_2[0]); + local8 = (local3 + 20); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) ((memory.readInt((int) local8 < 0 ? local8 : local8 + 0) - memory.readInt((int) local3 < 0 ? local3 : local3 + 16)) >> 3)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(251, callArgs_3); + local9 = ((int) callResult_3[0]); + label_4: { + label_5: { + local10 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local10) != 0) { + break label_5; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) -4294967296L); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local2 + 16)); + callArgs_4[1] = ((long) 30367); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_4); + local10 = 1; + break label_4; + } + local3 = memory.readInt((int) (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local10 - local3), 36) * 36) + local3) + -8) < 0 ? (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local10 - local3), 36) * 36) + local3) + -8) : (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local10 - local3), 36) * 36) + local3) + -8) + 0); + local10 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) 0L); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((local10 - local11) >> 3), local3); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) 1); + callArgs_5[3] = ((long) (local2 + 48)); + callArgs_5[2] = ((long) 13952); + callArgs_5[1] = ((long) local10); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(253, callArgs_5); + } + label_6: { + label_7: { + local3 = memory.readInt((int) (local5 + (arg1 * 36)) < 0 ? (local5 + (arg1 * 36)) : (local5 + (arg1 * 36)) + 28); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local5 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - arg1) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local3, local5) != 0) { + break label_7; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local3 - local5)); + callArgs_6[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_6); + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local5) != 0) { + break label_6; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (arg1 + (local3 << 3))); + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(6, local6); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7); + label_8: { + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local5 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local3) != 0) { + break label_8; + } + label_9: while (true) { + local12 = memory.readLong((int) local3 < 0 ? local3 : local3 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) local12); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local12); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) (local2 + 8)); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_7); + local3 = (local3 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + arg1 = (arg1 | local6); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local9); + label_10: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local3 = memory.readInt((int) (local5 + -20) < 0 ? (local5 + -20) : (local5 + -20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_10; + } + memory.writeI32((int) (local5 + -16) < 0 ? (local5 + -16) : (local5 + -16) + 0, (int) local3); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_8); + } + arg1 = (arg1 | local6); + label_11: { + local3 = memory.readInt((int) (local5 + -32) < 0 ? (local5 + -32) : (local5 + -32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_11; + } + memory.writeI32((int) (local5 + -28) < 0 ? (local5 + -28) : (local5 + -28) + 0, (int) local3); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_9); + } + local3 = (arg1 | local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (local5 + -36)); + } + instance.global(0).setValue(((long) (local2 + 64))); + return local3; + } + + public static long[] call_285(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_285(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_286(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_4; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local1); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + break label_3; + } + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 36) + -1); + local2 = memory.readInt((int) (local3 + (local4 * 36)) < 0 ? (local3 + (local4 * 36)) : (local3 + (local4 * 36)) + 28); + local5 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local7 = ((local5 - local6) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((local2 + 1), local7) != 0) { + break label_2; + } + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local2, local7) != 0) { + break label_6; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 - local7)); + callArgs_1[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_1); + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, local7) != 0) { + break label_5; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local6 + (local2 << 3))); + } + local2 = 0; + if (((int) memory.read((int) (local3 + (local4 * 36)) < 0 ? (local3 + (local4 * 36)) : (local3 + (local4 * 36)) + 32) & 0xFF) != 0) { + break label_1; + } + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 8); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local3 = ((int) callResult_2[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) -4294967296L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 16, (int) local3); + local2 = (local3 + 8); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 24, (int) local2); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 20, (int) local2); + local2 = 1; + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) (local1 + 16)); + callArgs_3[2] = ((long) 11906); + callArgs_3[1] = ((long) 1); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(253, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_4); + break label_1; + } + local2 = 0; + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 0); + callArgs_5[1] = ((long) local5); + callArgs_5[0] = ((long) (local5 + -8)); + long[] callResult_5 = instance.getMachine().call(1891, callArgs_5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) ((int) callResult_5[0])); + } + instance.global(0).setValue(((long) (local1 + 32))); + return local2; + } + + public static long[] call_286(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_286(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_287(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + long local11 = 0L; + local1 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + local2 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_2; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local1); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local3 = 1; + break label_1; + } + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 36) + -1); + local4 = (local3 + (local2 * 36)); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(4, memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 14295); + callArgs_1[1] = ((long) (local4 + 16)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(255, callArgs_1); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) ((memory.readInt((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0) - memory.readInt((int) local4 < 0 ? local4 : local4 + 16)) >> 3)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(251, callArgs_2); + local7 = ((int) callResult_2[0]); + label_3: { + label_4: { + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, local8) != 0) { + break label_4; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 16, (long) -4294967296L); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local1 + 16)); + callArgs_3[1] = ((long) 30367); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_3); + local8 = 1; + break label_3; + } + local9 = memory.readInt((int) (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local8 - local9), 36) * 36) + local9) + -8) < 0 ? (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local8 - local9), 36) * 36) + local9) + -8) : (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local8 - local9), 36) * 36) + local9) + -8) + 0); + local8 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local10 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 40, (int) 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 32, (long) 0L); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((local8 - local10) >> 3), local9); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) 1); + callArgs_4[3] = ((long) (local1 + 32)); + callArgs_4[2] = ((long) 14295); + callArgs_4[1] = ((long) local8); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(253, callArgs_4); + } + local5 = (local5 | local6); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7); + label_5: { + label_6: { + local9 = memory.readInt((int) (local3 + (local2 * 36)) < 0 ? (local3 + (local2 * 36)) : (local3 + (local2 * 36)) + 28); + local10 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local7 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local10) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local9, local7) != 0) { + break label_6; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local9 - local7)); + callArgs_5[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_5); + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, local7) != 0) { + break label_5; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local10 + (local9 << 3))); + } + local5 = (local5 | local6); + label_7: { + local9 = (local3 + (local2 * 36)); + local3 = memory.readInt((int) local9 < 0 ? local9 : local9 + 4); + local2 = memory.readInt((int) (local9 + 8) < 0 ? (local9 + 8) : (local9 + 8) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local3) != 0) { + break label_7; + } + label_8: while (true) { + local11 = memory.readLong((int) local3 < 0 ? local3 : local3 + 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 32, (long) local11); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 8, (long) local11); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local1 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_6); + local3 = (local3 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + local3 = (local5 | local8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 5); + memory.writeByte((int) local9 < 0 ? local9 : local9 + 32, (byte) (0)); + } + instance.global(0).setValue(((long) (local1 + 48))); + return local3; + } + + public static long[] call_287(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_287(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_288(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) (arg1 + 16)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(255, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) ((memory.readInt((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)) >> 3)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(251, callArgs_1); + local6 = ((int) callResult_1[0]); + label_1: { + label_2: { + local7 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, local7) != 0) { + break label_2; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) -4294967296L); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 16)); + callArgs_2[1] = ((long) 30367); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_2); + local7 = 1; + break label_1; + } + arg2 = memory.readInt((int) (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local7 - arg2), 36) * 36) + arg2) + -8) < 0 ? (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local7 - arg2), 36) * 36) + arg2) + -8) : (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local7 - arg2), 36) * 36) + arg2) + -8) + 0); + local7 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 40, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 32, (long) 0L); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((local7 - local8) >> 3), arg2); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 1); + callArgs_3[3] = ((long) (local4 + 32)); + callArgs_3[2] = ((long) arg3); + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(253, callArgs_3); + } + label_3: { + label_4: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 28); + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + arg3 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local8) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg2, arg3) != 0) { + break label_4; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (arg2 - arg3)); + callArgs_4[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_4); + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, arg3) != 0) { + break label_3; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local8 + (arg2 << 3))); + } + label_5: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_5; + } + label_6: while (true) { + local9 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 32, (long) local9); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local9); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local4 + 8)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_5); + arg2 = (arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + label_7: { + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + arg1 = memory.readInt((int) (arg2 + -20) < 0 ? (arg2 + -20) : (arg2 + -20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_7; + } + memory.writeI32((int) (arg2 + -16) < 0 ? (arg2 + -16) : (arg2 + -16) + 0, (int) arg1); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_6); + } + label_8: { + arg1 = memory.readInt((int) (arg2 + -32) < 0 ? (arg2 + -32) : (arg2 + -32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_8; + } + memory.writeI32((int) (arg2 + -28) < 0 ? (arg2 + -28) : (arg2 + -28) + 0, (int) arg1); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_7); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (arg2 + -36)); + instance.global(0).setValue(((long) (local4 + 48))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6)) | local7); + } + + public static long[] call_288(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_288(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_289(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + local2 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_2; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local1); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local3 = 1; + break label_1; + } + label_3: { + local2 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 36) * 36) + local3) + -36); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(4, local3) != 0) { + break label_3; + } + local3 = 1; + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(287, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + } + local3 = memory.readInt((int) ((local3 << 2) + 42032) < 0 ? ((local3 << 2) + 42032) : ((local3 << 2) + 42032) + 0); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) local2); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(288, callArgs_2); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])); + } + instance.global(0).setValue(((long) (local1 + 16))); + return local3; + } + + public static long[] call_289(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_289(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_290(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) -1L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) -1L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 14761); + callArgs_0[1] = ((long) (local3 + 16)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(257, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 14761); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(255, callArgs_1); + local5 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(251, callArgs_2); + local6 = ((int) callResult_2[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) 4); + local7 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)) >> 3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local7); + label_1: { + label_2: { + local8 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0)) != 0) { + break label_2; + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) local7); + callArgs_3[3] = ((long) arg2); + callArgs_3[2] = ((long) arg1); + callArgs_3[1] = ((long) 4); + callArgs_3[0] = ((long) local8); + long[] callResult_3 = instance.getMachine().call(245, callArgs_3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (((int) callResult_3[0]) + 36)); + break label_1; + } + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) (local3 + 36)); + callArgs_4[3] = ((long) arg2); + callArgs_4[2] = ((long) arg1); + callArgs_4[1] = ((long) (local3 + 40)); + callArgs_4[0] = ((long) (arg0 + 28)); + instance.getMachine().call(249, callArgs_4); + } + label_3: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_3; + } + label_4: while (true) { + local9 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local9); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local9); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 8)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_5); + arg2 = (arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + instance.global(0).setValue(((long) (local3 + 48))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6)); + } + + public static long[] call_290(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_290(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_291(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_0); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_291(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_291(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_292(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 7312); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(257, callArgs_0); + arg1 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return arg1; + } + + public static long[] call_292(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_292(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_293(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 40)); + callArgs_0[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 40)); + callArgs_1[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 32)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + callArgs_2[1] = ((long) (local3 + 16)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(257, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 40)); + callArgs_3[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_3); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 56); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_4); + instance.global(0).setValue(((long) (local3 + 112))); + return arg1; + } + + public static long[] call_293(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_293(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_294(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_0); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_294(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_294(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_295(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 7302); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(257, callArgs_0); + arg1 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return arg1; + } + + public static long[] call_295(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_295(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_296(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 17463); + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(257, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) local3); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local2); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_1); + instance.global(0).setValue(((long) (local2 + 32))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1); + } + + public static long[] call_296(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_296(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_297(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 11911); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(255, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(251, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) 3); + local6 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)) >> 3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local6); + label_1: { + label_2: { + local7 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0)) != 0) { + break label_2; + } + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) local6); + callArgs_2[3] = ((long) arg2); + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 3); + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(245, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (((int) callResult_2[0]) + 36)); + break label_1; + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) (local3 + 20)); + callArgs_3[3] = ((long) arg2); + callArgs_3[2] = ((long) arg1); + callArgs_3[1] = ((long) (local3 + 24)); + callArgs_3[0] = ((long) (arg0 + 28)); + instance.getMachine().call(249, callArgs_3); + } + label_3: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_3; + } + label_4: while (true) { + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local8); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_4); + arg2 = (arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + instance.global(0).setValue(((long) (local3 + 32))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)); + } + + public static long[] call_297(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_297(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_298(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (long) memory.readLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF)) != 0) { + break label_1; + } + if ((((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 18) & 0xFF) & 255) != 0) { + break label_1; + } + memory.writeI32((int) ((local3 + 8) + 15) < 0 ? ((local3 + 8) + 15) : ((local3 + 8) + 15) + 0, (int) memory.readInt((int) (arg1 + 15) < 0 ? (arg1 + 15) : (arg1 + 15) + 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + } + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) (local3 + 8)); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 206); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(260, callArgs_0); + arg2 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local3 + 32))); + return arg2; + } + + public static long[] call_298(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_298(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_299(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_299(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_299(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_300(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) arg1); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 207); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(260, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_300(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_300(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_301(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 18) & 0xFF) != 0 ? -2 : -1)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 24)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 2757); + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(257, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 18) & 0xFF) != 0 ? -2 : -1)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local2); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_1); + instance.global(0).setValue(((long) (local2 + 32))); + return local3; + } + + public static long[] call_301(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_301(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_302(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 72, (int) 204); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 72)); + callArgs_0[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 68, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 64, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 72)); + callArgs_1[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 56, (long) memory.readLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 72)); + callArgs_2[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) memory.readLong((int) (local3 + 112) < 0 ? (local3 + 112) : (local3 + 112) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 72)); + callArgs_3[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 64)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 56)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 80)); + callArgs_4[3] = ((long) (local3 + 16)); + callArgs_4[2] = ((long) (local3 + 24)); + callArgs_4[1] = ((long) (local3 + 32)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(259, callArgs_4); + arg2 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 72)); + callArgs_5[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_5); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 88); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local3 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_6); + instance.global(0).setValue(((long) (local3 + 144))); + return arg2; + } + + public static long[] call_302(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_302(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_303(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 18) & 0xFF) != 0 ? -2 : -1)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_0); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_303(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_303(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_304(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (long) memory.readLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF)) != 0) { + break label_1; + } + if ((((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 18) & 0xFF) & 255) != 0) { + break label_1; + } + memory.writeI32((int) ((local3 + 8) + 15) < 0 ? ((local3 + 8) + 15) : ((local3 + 8) + 15) + 0, (int) memory.readInt((int) (arg1 + 15) < 0 ? (arg1 + 15) : (arg1 + 15) + 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + } + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) (local3 + 8)); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 210); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(260, callArgs_0); + arg2 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local3 + 32))); + return arg2; + } + + public static long[] call_304(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_304(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_305(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_305(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_305(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_306(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 72, (int) 208); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 72)); + callArgs_0[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 68, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 64, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 72)); + callArgs_1[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 56, (long) memory.readLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 72)); + callArgs_2[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) memory.readLong((int) (local3 + 112) < 0 ? (local3 + 112) : (local3 + 112) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 72)); + callArgs_3[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 64)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 56)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 80)); + callArgs_4[3] = ((long) (local3 + 16)); + callArgs_4[2] = ((long) (local3 + 24)); + callArgs_4[1] = ((long) (local3 + 32)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(259, callArgs_4); + arg2 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 72)); + callArgs_5[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_5); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 88); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local3 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_6); + instance.global(0).setValue(((long) (local3 + 144))); + return arg2; + } + + public static long[] call_306(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_306(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_307(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 211); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 56)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 56)); + callArgs_1[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + callArgs_2[1] = ((long) (local3 + 24)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(257, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 56)); + callArgs_3[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_3); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 72); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) local4); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 16)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_4); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 8)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_5); + instance.global(0).setValue(((long) (local3 + 128))); + return arg2; + } + + public static long[] call_307(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_307(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_308(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 24)); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 7323); + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(258, callArgs_0); + arg2 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local3 + 32))); + return arg2; + } + + public static long[] call_308(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_308(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_309(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 32)); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 2769); + callArgs_0[2] = ((long) (local3 + 8)); + callArgs_0[1] = ((long) (local3 + 16)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(258, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 24)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_1); + instance.global(0).setValue(((long) (local3 + 48))); + return arg1; + } + + public static long[] call_309(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_309(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_310(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 18) & 0xFF) != 0 ? -2 : -1)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_0); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_310(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_310(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_311(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) -1); + arg2 = (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 44, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) arg2); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 24)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 40)); + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 13256); + callArgs_0[3] = ((long) local3); + callArgs_0[2] = ((long) (local3 + 8)); + callArgs_0[1] = ((long) (local3 + 16)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(259, callArgs_0); + arg2 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local3 + 48))); + return arg2; + } + + public static long[] call_311(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_311(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_312(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (arg0 + 50) < 0 ? (arg0 + 50) : (arg0 + 50) + 0) & 0xFF)) != 0) { + break label_2; + } + if (arg2 != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) -21); + arg2 = (local3 + 24); + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) -16); + arg1 = -1; + arg2 = (local3 + 16); + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_0); + instance.global(0).setValue(((long) (local3 + 32))); + return 0; + } + + public static long[] call_312(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_312(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_313(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_0); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_313(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_313(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_314(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + long local4 = 0L; + long local5 = 0L; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local1 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + local2 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_2; + } + local4 = -4294967296L; + memory.writeLong((int) local1 < 0 ? local1 : local1 + 16, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local1 + 16)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local5 = 4294967275L; + local2 = 1; + break label_1; + } + label_3: { + local3 = (local3 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 36) + -1) * 36)); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local7 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local6) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(memory.readInt((int) local3 < 0 ? local3 : local3 + 28), local7) != 0) { + break label_3; + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 32) & 0xFF)); + local4 = -4294967296L; + local5 = 4294967275L; + break label_1; + } + local4 = -4294967296L; + local5 = 4294967275L; + local2 = 0; + local8 = memory.readLong((int) (((local7 << 3) + local6) + -8) < 0 ? (((local7 << 3) + local6) + -8) : (((local7 << 3) + local6) + -8) + 0); + local3 = ((int) local8 + 23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 7) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((1 << local3) & 197)) != 0) { + break label_1; + } + local5 = (local8 & 4294967295L); + local4 = (local8 & -4294967296L); + } + local4 = (local4 | local5); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 8, (long) local4); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 40, (long) local4); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 13223); + callArgs_1[1] = ((long) (local1 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(257, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) -1L); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 32, (long) -1L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local1); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_2); + instance.global(0).setValue(((long) (local1 + 48))); + return (local2 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3)); + } + + public static long[] call_314(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_314(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_315(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local2 + 12)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(247, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + label_2: { + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + local3 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 36) * 36) + arg1) + -36); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 32, (byte) (1)); + label_3: { + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 28); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local4 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local5) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg1, local4) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 - local4)); + callArgs_1[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_1); + local3 = 0; + break label_1; + } + local3 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local4) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local5 + (arg1 << 3))); + break label_1; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) -4294967296L); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 30367); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_315(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_315(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_316(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 2751); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(255, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(251, callArgs_1); + local4 = ((int) callResult_1[0]); + label_1: { + label_2: { + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local5) != 0) { + break label_2; + } + local3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4)); + arg1 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - arg1), 36) * 36) + arg1) + -36); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 32, (byte) (1)); + label_3: { + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 28); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local4 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local5) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg1, local4) != 0) { + break label_3; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 - local4)); + callArgs_2[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_2); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local4) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local5 + (arg1 << 3))); + break label_1; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) -4294967296L); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 30367); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_3); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_316(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_316(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_317(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local1)); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 16, (long) -23L); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 24, (long) -23L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 14837); + callArgs_0[1] = ((long) (local1 + 16)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(257, callArgs_0); + local2 = ((int) callResult_0[0]); + label_1: { + label_2: { + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_2; + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local2); + local4 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 36) * 36) + local4) + -36); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 32, (byte) (1)); + label_3: { + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 28); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local3 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local5) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local4, local3) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local4 - local3)); + callArgs_1[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_1); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local3) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local5 + (local4 << 3))); + break label_1; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) -4294967296L); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local1); + callArgs_2[1] = ((long) 30367); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_2); + local2 = 1; + } + instance.global(0).setValue(((long) (local1 + 32))); + return local2; + } + + public static long[] call_317(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_317(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_318(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0)) != 0) { + break label_3; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) -1L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local1); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + break label_2; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 12278); + callArgs_1[1] = ((long) (local2 + 16)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(255, callArgs_1); + local3 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) ((memory.readInt((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0) - memory.readInt((int) local2 < 0 ? local2 : local2 + 16)) >> 3)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(251, callArgs_2); + local2 = ((int) callResult_2[0]); + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local4) != 0) { + break label_4; + } + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local2)); + local5 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local5), 36) * 36) + local5) + -36); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 32, (byte) (1)); + label_5: { + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local3 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local4) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local5, local3) != 0) { + break label_5; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 - local3)); + callArgs_3[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_3); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local3) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local4 + (local5 << 3))); + break label_1; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 16, (long) -4294967296L); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local1 + 16)); + callArgs_4[1] = ((long) 30367); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_4); + } + local2 = 1; + } + instance.global(0).setValue(((long) (local1 + 32))); + return local2; + } + + public static long[] call_318(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_318(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_319(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + int local11 = 0; + long local12 = 0L; + local2 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_2; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 64, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local2 + 64)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local5 = 1; + break label_1; + } + label_3: { + local6 = (local4 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 36) + -1) * 36)); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local7 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local5) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(memory.readInt((int) local6 < 0 ? local6 : local6 + 28), local7) != 0) { + break label_3; + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 32) & 0xFF)); + break label_1; + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((memory.readInt((int) (((local7 << 3) + local5) + -8) < 0 ? (((local7 << 3) + local5) + -8) : (((local7 << 3) + local5) + -8) + 0) + -1), -2); + } + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_5; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) -4294967296L); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 48)); + callArgs_1[1] = ((long) 30367); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_1); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local7 = 1; + local8 = -1; + local6 = 0; + break label_4; + } + local8 = -1; + label_6: { + local6 = (local4 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 36) + -1) * 36)); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local9 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local7) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((memory.readInt((int) local6 < 0 ? local6 : local6 + 28) + 1), local9) != 0) { + break label_6; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 32) & 0xFF)); + local6 = 0; + break label_4; + } + local10 = memory.readLong((int) (((local9 << 3) + local7) + -16) < 0 ? (((local9 << 3) + local7) + -16) : (((local9 << 3) + local7) + -16) + 0); + local6 = (int) local10; + local8 = (int) (local10 >>> 32L); + local7 = 0; + } + local5 = (local5 | local7); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_8; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) -4294967296L); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local2 + 32)); + callArgs_2[1] = ((long) 30367); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_2); + local3 = 1; + local9 = -1; + local4 = 0; + break label_7; + } + local9 = -1; + label_9: { + local4 = (local4 + ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 36) + -1) * 36)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local7 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local3) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((memory.readInt((int) local4 < 0 ? local4 : local4 + 28) + 2), local7) != 0) { + break label_9; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 32) & 0xFF)); + local4 = 0; + break label_7; + } + local10 = memory.readLong((int) (((local7 << 3) + local3) + -24) < 0 ? (((local7 << 3) + local3) + -24) : (((local7 << 3) + local3) + -24) + 0); + local4 = (int) local10; + local9 = (int) (local10 >>> 32L); + local3 = 0; + } + local5 = (local5 | local3); + label_10: { + label_11: { + label_12: { + label_13: { + label_14: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4), local3) != 0) { + break label_14; + } + local3 = (local6 + 23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 8) != 0) { + break label_13; + } + break label_12; + } + local10 = memory.readLong((int) local3 < 0 ? local3 : local3 + 0); + local11 = (int) (local10 >>> 32L); + local7 = 0; + arg1 = 0; + label_15: { + local3 = (int) local10; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_15; + } + arg1 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_15; + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local3) != 0) { + break label_16; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local6) != 0) { + break label_16; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, local8); + break label_15; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local6); + } + arg1 = (local5 | arg1); + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_17; + } + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local3) != 0) { + break label_18; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local4) != 0) { + break label_18; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, local9); + break label_17; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local4); + } + local3 = 0; + local10 = -4294967296L; + if ((arg1 | local7) != 0) { + break label_11; + } + break label_10; + } + local10 = -4294967296L; + if (((197 >>> (local3 & 255)) & 1) != 0) { + break label_11; + } + } + label_19: { + local3 = (local4 + 23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 8) != 0) { + break label_19; + } + local10 = -4294967296L; + if (((197 >>> (local3 & 255)) & 1) != 0) { + break label_11; + } + } + local10 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local8) << 32L); + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local6); + local3 = 0; + arg1 = 0; + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_20; + } + arg1 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_20; + } + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local4) != 0) { + break label_21; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local6) != 0) { + break label_21; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local9); + break label_20; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local6); + } + local10 = (local10 | local12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local5 | arg1)) != 0) { + break label_10; + } + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 24); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local4 = ((int) callResult_3[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) -1L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local10); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) local10); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) local4); + local3 = (local4 + 24); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 88, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) local3); + local3 = 1; + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) 0); + callArgs_4[3] = ((long) (local2 + 80)); + callArgs_4[2] = ((long) 7500); + callArgs_4[1] = ((long) 1); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(253, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_5); + } + label_22: { + label_23: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, arg1) != 0) { + break label_23; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) -4294967296L); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) (local2 + 16)); + callArgs_6[1] = ((long) 30367); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_6); + local4 = 1; + break label_22; + } + label_24: { + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local4), 36) + -1); + arg1 = memory.readInt((int) (local4 + (local7 * 36)) < 0 ? (local4 + (local7 * 36)) : (local4 + (local7 * 36)) + 28); + local6 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local5 = ((local6 - local8) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((arg1 + 3), local5) != 0) { + break label_24; + } + label_25: { + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg1, local5) != 0) { + break label_26; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) (arg1 - local5)); + callArgs_7[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_7); + break label_25; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local5) != 0) { + break label_25; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local8 + (arg1 << 3))); + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (local4 + (local7 * 36)) < 0 ? (local4 + (local7 * 36)) : (local4 + (local7 * 36)) + 32) & 0xFF)); + break label_22; + } + local4 = 0; + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 0); + callArgs_8[1] = ((long) local6); + callArgs_8[0] = ((long) (local6 + -24)); + long[] callResult_8 = instance.getMachine().call(1891, callArgs_8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) ((int) callResult_8[0])); + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local10); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) local10); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) (local2 + 8)); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_9); + instance.global(0).setValue(((long) (local2 + 96))); + return (local3 | local4); + } + + public static long[] call_319(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_319(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_320(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 56)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 + 56)); + callArgs_1[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) memory.readLong((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 56)); + callArgs_2[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 48)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 40)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) (local3 + 24)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(258, callArgs_3); + arg1 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 56)); + callArgs_4[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_4); + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 72); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 8)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_5); + instance.global(0).setValue(((long) (local3 + 128))); + return arg1; + } + + public static long[] call_320(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_320(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_321(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 1118); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(255, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(251, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) 6); + local6 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)) >> 3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local6); + label_1: { + label_2: { + local7 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0)) != 0) { + break label_2; + } + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) local6); + callArgs_2[3] = ((long) arg2); + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 6); + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(245, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (((int) callResult_2[0]) + 36)); + break label_1; + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) (local3 + 20)); + callArgs_3[3] = ((long) arg2); + callArgs_3[2] = ((long) arg1); + callArgs_3[1] = ((long) (local3 + 24)); + callArgs_3[0] = ((long) (arg0 + 28)); + instance.getMachine().call(249, callArgs_3); + } + label_3: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_3; + } + label_4: while (true) { + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local8); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_4); + arg2 = (arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + instance.global(0).setValue(((long) (local3 + 32))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)); + } + + public static long[] call_321(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_321(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_322(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 17231); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(255, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(251, callArgs_1); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0]))); + } + + public static long[] call_322(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_322(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_323(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + int local10 = 0; + long local11 = 0L; + int local12 = 0; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0) - local4), 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, arg2) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) (local5 + -1)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 16)); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + break label_2; + } + label_4: { + arg2 = (local4 + ((local5 + (arg2 ^ -1)) * 36)); + local6 = (arg2 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(3, memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)) != 0 ? 4 : 16)); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + local4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + arg2 = ((local7 - local4) >> 3); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - local5) >> 3), arg2) != 0) { + break label_4; + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local7) != 0) { + break label_5; + } + arg2 = 0; + break label_1; + } + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 1) != 0 ? arg2 : 1); + local7 = 0; + label_6: while (true) { + arg2 = 0; + label_7: { + local9 = memory.readLong((int) local5 < 0 ? local5 : local5 + 0); + local10 = (int) local9; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_7; + } + arg2 = 0; + local11 = memory.readLong((int) local4 < 0 ? local4 : local4 + 0); + local12 = (int) local11; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_7; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local10) != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local12) != 0) { + break label_8; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((int) (local11 >>> 32L), (int) (local9 >>> 32L)); + break label_7; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local10, local12); + } + local4 = (local4 + 8); + local5 = (local5 + 8); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local7) | arg2); + local8 = (local8 + -1); + if (local8 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + arg2 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 0); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local3 + 48)); + instance.getMachine().call(254, callArgs_1); + arg2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + local5 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 59); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) local6); + callArgs_2[0] = ((long) (local3 + 32)); + instance.getMachine().call(254, callArgs_2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, 0) != 0 ? arg2 : (local3 + 48))); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 32) : (local3 + 32))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local3); + callArgs_3[1] = ((long) 10485); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_3); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), -1) != 0) { + break label_9; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + instance.getMachine().call(1777, callArgs_4); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 59), -1) != 0) { + break label_2; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + instance.getMachine().call(1777, callArgs_5); + } + arg2 = 1; + } + instance.global(0).setValue(((long) (local3 + 64))); + return arg2; + } + + public static long[] call_323(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_323(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_324(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) 7); + local4 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)) >> 3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local4); + label_1: { + label_2: { + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0)) != 0) { + break label_2; + } + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) local4); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 7); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(245, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (((int) callResult_0[0]) + 36)); + break label_1; + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) (local3 + 20)); + callArgs_1[3] = ((long) arg2); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (local3 + 24)); + callArgs_1[0] = ((long) (arg0 + 28)); + instance.getMachine().call(249, callArgs_1); + } + label_3: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_3; + } + label_4: while (true) { + local6 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local6); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local6); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 8)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_2); + arg2 = (arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + instance.global(0).setValue(((long) (local3 + 32))); + return 0; + } + + public static long[] call_324(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_324(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_325(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 40)); + callArgs_0[0] = ((long) (local2 + 48)); + instance.getMachine().call(192, callArgs_0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 + 40)); + callArgs_1[0] = ((long) (local2 + 48)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 32)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 48)); + callArgs_2[1] = ((long) (local2 + 16)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(257, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 40)); + callArgs_3[0] = ((long) (local2 + 48)); + instance.getMachine().call(192, callArgs_3); + local3 = memory.readLong((int) local2 < 0 ? local2 : local2 + 56); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_4); + instance.global(0).setValue(((long) (local2 + 112))); + return arg1; + } + + public static long[] call_325(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_325(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_326(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 72, (int) arg1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 72)); + callArgs_0[0] = ((long) (local2 + 80)); + instance.getMachine().call(192, callArgs_0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 64, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 96)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 + 72)); + callArgs_1[0] = ((long) (local2 + 80)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) memory.readLong((int) (local2 + 104) < 0 ? (local2 + 104) : (local2 + 104) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 72)); + callArgs_2[0] = ((long) (local2 + 80)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) memory.readLong((int) (local2 + 112) < 0 ? (local2 + 112) : (local2 + 112) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 72)); + callArgs_3[0] = ((long) (local2 + 80)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 48)); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 80)); + callArgs_4[3] = ((long) (local2 + 16)); + callArgs_4[2] = ((long) (local2 + 24)); + callArgs_4[1] = ((long) (local2 + 32)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(259, callArgs_4); + arg1 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local2 + 72)); + callArgs_5[0] = ((long) (local2 + 80)); + instance.getMachine().call(192, callArgs_5); + local3 = memory.readLong((int) local2 < 0 ? local2 : local2 + 88); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local2 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_6); + instance.global(0).setValue(((long) (local2 + 144))); + return arg1; + } + + public static long[] call_326(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_326(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_327(int arg0, int arg1, long arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + int local5 = 0; + long local6 = 0L; + local3 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 72, (int) arg1); + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 72)); + long[] callResult_0 = instance.getMachine().call(195, callArgs_0); + arg1 = ((int) callResult_0[0]); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local4, arg2) != 0) { + break label_1; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 56, (long) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) arg1); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 48)); + callArgs_1[1] = ((long) 29911); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_1); + } + label_2: { + label_3: { + label_4: { + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 72); + local5 = (arg1 + -240); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 13) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((1 << local5) & 5467)) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 80, (int) arg1); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 80)); + callArgs_2[0] = ((long) (local3 + 112)); + instance.getMachine().call(192, callArgs_2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 96, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 128)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 80)); + callArgs_3[0] = ((long) (local3 + 112)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 96)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 112)); + callArgs_4[1] = ((long) (local3 + 16)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(257, callArgs_4); + arg1 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 80)); + callArgs_5[0] = ((long) (local3 + 112)); + instance.getMachine().call(192, callArgs_5); + local6 = memory.readLong((int) local3 < 0 ? local3 : local3 + 120); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 88, (long) local6); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local6); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local3 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_6); + break label_2; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 104, (int) arg1); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) (local3 + 104)); + callArgs_8[0] = ((long) (local3 + 112)); + instance.getMachine().call(192, callArgs_8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 96, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 128)); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) (local3 + 104)); + callArgs_9[0] = ((long) (local3 + 112)); + instance.getMachine().call(192, callArgs_9); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 88, (long) memory.readLong((int) (local3 + 136) < 0 ? (local3 + 136) : (local3 + 136) + 0)); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) (local3 + 104)); + callArgs_10[0] = ((long) (local3 + 112)); + instance.getMachine().call(192, callArgs_10); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 96)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 88)); + long[] callArgs_11 = new long[4]; + callArgs_11[3] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 112)); + callArgs_11[2] = ((long) (local3 + 32)); + callArgs_11[1] = ((long) (local3 + 40)); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(258, callArgs_11); + arg1 = ((int) callResult_11[0]); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) (local3 + 104)); + callArgs_12[0] = ((long) (local3 + 112)); + instance.getMachine().call(192, callArgs_12); + local6 = memory.readLong((int) local3 < 0 ? local3 : local3 + 120); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 80, (long) local6); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local6); + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) (local3 + 24)); + callArgs_13[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_13); + } + instance.global(0).setValue(((long) (local3 + 176))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local4, arg2) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)); + } + + public static long[] call_327(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + long arg2 = args[2]; + int result = Wat2WasmMachine.func_327(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_328(int arg0, int arg1, int arg2, long arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + long local5 = 0L; + long local6 = 0L; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 56, (int) arg1); + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 56)); + long[] callResult_0 = instance.getMachine().call(195, callArgs_0); + arg1 = ((int) callResult_0[0]); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local5, arg3) != 0) { + break label_1; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) arg1); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local4 + 32)); + callArgs_1[1] = ((long) 29911); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_1); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 88, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 56)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 88)); + callArgs_2[0] = ((long) (local4 + 96)); + instance.getMachine().call(192, callArgs_2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 84, (int) -1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 80, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local4 + 88)); + callArgs_3[0] = ((long) (local4 + 96)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 72, (long) memory.readLong((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local4 + 88)); + callArgs_4[0] = ((long) (local4 + 96)); + instance.getMachine().call(192, callArgs_4); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 80)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 72)); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 96)); + callArgs_5[2] = ((long) (local4 + 16)); + callArgs_5[1] = ((long) (local4 + 24)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(258, callArgs_5); + arg1 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local4 + 88)); + callArgs_6[0] = ((long) (local4 + 96)); + instance.getMachine().call(192, callArgs_6); + local6 = memory.readLong((int) local4 < 0 ? local4 : local4 + 104); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 64, (long) local6); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) (local4 + 8)); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_7); + instance.global(0).setValue(((long) (local4 + 160))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local5, arg3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)); + } + + public static long[] call_328(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + int result = Wat2WasmMachine.func_328(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_329(int arg0, int arg1, int arg2, long arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + long local5 = 0L; + long local6 = 0L; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 56, (int) arg1); + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 56)); + long[] callResult_0 = instance.getMachine().call(195, callArgs_0); + arg1 = ((int) callResult_0[0]); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local5, arg3) != 0) { + break label_1; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) arg1); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local4 + 32)); + callArgs_1[1] = ((long) 29911); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_1); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 88, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 56)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 88)); + callArgs_2[0] = ((long) (local4 + 96)); + instance.getMachine().call(192, callArgs_2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 84, (int) -1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 80, (int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -2 : -1)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local4 + 88)); + callArgs_3[0] = ((long) (local4 + 96)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 72, (long) memory.readLong((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local4 + 88)); + callArgs_4[0] = ((long) (local4 + 96)); + instance.getMachine().call(192, callArgs_4); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 80)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 72)); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 96)); + callArgs_5[2] = ((long) (local4 + 16)); + callArgs_5[1] = ((long) (local4 + 24)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(258, callArgs_5); + arg1 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local4 + 88)); + callArgs_6[0] = ((long) (local4 + 96)); + instance.getMachine().call(192, callArgs_6); + local6 = memory.readLong((int) local4 < 0 ? local4 : local4 + 104); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 64, (long) local6); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) (local4 + 8)); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_7); + instance.global(0).setValue(((long) (local4 + 160))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local5, arg3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)); + } + + public static long[] call_329(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + int result = Wat2WasmMachine.func_329(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_330(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + long local20 = 0L; + local3 = (((int) instance.global(0).getValue()) - 384); + instance.global(0).setValue(((long) local3)); + local4 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 15) & 0xFF); + local5 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 14) & 0xFF); + local6 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 13) & 0xFF); + local7 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 12) & 0xFF); + local8 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 11) & 0xFF); + local9 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 10) & 0xFF); + local10 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 9) & 0xFF); + local11 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 8) & 0xFF); + local12 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 7) & 0xFF); + local13 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 6) & 0xFF); + local14 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 5) & 0xFF); + local15 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 4) & 0xFF); + local16 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 3) & 0xFF); + local17 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 2) & 0xFF); + local18 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 1) & 0xFF); + local19 = 0; + label_1: { + arg2 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 32) != 0) { + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 272, (int) arg2); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 272)); + callArgs_0[1] = ((long) 30465); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local19 = 1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local18, 32) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 256, (int) local18); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 256)); + callArgs_1[1] = ((long) 30465); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_1); + local19 = 1; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local17, 32) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 240, (int) local17); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 240)); + callArgs_2[1] = ((long) 30465); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_2); + local19 = 1; + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local16, 32) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 224, (int) local16); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 224)); + callArgs_3[1] = ((long) 30465); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_3); + local19 = 1; + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local15, 32) != 0) { + break label_5; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 208, (int) local15); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local3 + 208)); + callArgs_4[1] = ((long) 30465); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_4); + local19 = 1; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local14, 32) != 0) { + break label_6; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 192, (int) local14); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local3 + 192)); + callArgs_5[1] = ((long) 30465); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_5); + local19 = 1; + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local13, 32) != 0) { + break label_7; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 176, (int) local13); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) (local3 + 176)); + callArgs_6[1] = ((long) 30465); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_6); + local19 = 1; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local12, 32) != 0) { + break label_8; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 160, (int) local12); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local3 + 160)); + callArgs_7[1] = ((long) 30465); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_7); + local19 = 1; + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local11, 32) != 0) { + break label_9; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 144, (int) local11); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (local3 + 144)); + callArgs_8[1] = ((long) 30465); + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_8); + local19 = 1; + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, 32) != 0) { + break label_10; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 128, (int) local10); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local3 + 128)); + callArgs_9[1] = ((long) 30465); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_9); + local19 = 1; + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, 32) != 0) { + break label_11; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 112, (int) local9); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) (local3 + 112)); + callArgs_10[1] = ((long) 30465); + callArgs_10[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_10); + local19 = 1; + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 32) != 0) { + break label_12; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 96, (int) local8); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local3 + 96)); + callArgs_11[1] = ((long) 30465); + callArgs_11[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_11); + local19 = 1; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 32) != 0) { + break label_13; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 80, (int) local7); + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) (local3 + 80)); + callArgs_12[1] = ((long) 30465); + callArgs_12[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_12); + local19 = 1; + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 32) != 0) { + break label_14; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 64, (int) local6); + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) (local3 + 64)); + callArgs_13[1] = ((long) 30465); + callArgs_13[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_13); + local19 = 1; + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 32) != 0) { + break label_15; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) local5); + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) (local3 + 48)); + callArgs_14[1] = ((long) 30465); + callArgs_14[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_14); + local19 = 1; + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 32) != 0) { + break label_16; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local4); + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) (local3 + 32)); + callArgs_15[1] = ((long) 30465); + callArgs_15[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_15); + local19 = 1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 312, (int) arg1); + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) (local3 + 312)); + callArgs_16[0] = ((long) (local3 + 320)); + instance.getMachine().call(192, callArgs_16); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 304, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 336)); + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) (local3 + 312)); + callArgs_17[0] = ((long) (local3 + 320)); + instance.getMachine().call(192, callArgs_17); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 296, (long) memory.readLong((int) (local3 + 344) < 0 ? (local3 + 344) : (local3 + 344) + 0)); + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) (local3 + 312)); + callArgs_18[0] = ((long) (local3 + 320)); + instance.getMachine().call(192, callArgs_18); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 304)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 296)); + long[] callArgs_19 = new long[4]; + callArgs_19[3] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 320)); + callArgs_19[2] = ((long) (local3 + 16)); + callArgs_19[1] = ((long) (local3 + 24)); + callArgs_19[0] = ((long) arg0); + long[] callResult_19 = instance.getMachine().call(258, callArgs_19); + arg2 = ((int) callResult_19[0]); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) (local3 + 312)); + callArgs_20[0] = ((long) (local3 + 320)); + instance.getMachine().call(192, callArgs_20); + local20 = memory.readLong((int) local3 < 0 ? local3 : local3 + 328); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 288, (long) local20); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local20); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) (local3 + 8)); + callArgs_21[0] = ((long) arg0); + instance.getMachine().call(252, callArgs_21); + instance.global(0).setValue(((long) (local3 + 384))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local19) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)); + } + + public static long[] call_330(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_330(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_331(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + local2 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_2; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local1); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + local3 = 1; + break label_1; + } + local3 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 36) * 36) + local3) + -36); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 32, (byte) (1)); + label_3: { + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 28); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local5 = ((memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) - local4) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local2, local5) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 - local5)); + callArgs_1[0] = ((long) (arg0 + 16)); + instance.getMachine().call(248, callArgs_1); + local3 = 0; + break label_1; + } + local3 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, local5) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local4 + (local2 << 3))); + } + instance.global(0).setValue(((long) (local1 + 16))); + return local3; + } + + public static long[] call_331(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_331(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_332(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + local2 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_2; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local1); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + arg0 = 1; + break label_1; + } + local3 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 36) * 36) + local3) + -36); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) 12348); + callArgs_1[2] = ((long) 12269); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(288, callArgs_1); + arg0 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, memory.readInt((int) local3 < 0 ? local3 : local3 + 0)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0]))); + } + instance.global(0).setValue(((long) (local1 + 16))); + return arg0; + } + + public static long[] call_332(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_332(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_333(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeI32((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (int) local3); + local4 = local3; + label_1: { + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local5) != 0) { + break label_1; + } + local5 = (local5 + -32); + label_2: while (true) { + label_3: { + local3 = memory.readInt((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + memory.writeI32((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (int) local3); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_0); + } + label_4: { + local3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_4; + } + memory.writeI32((int) (local5 + 4) < 0 ? (local5 + 4) : (local5 + 4) + 0, (int) local3); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + local3 = (local5 + -4); + local5 = (local5 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) 0L); + local7 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 8); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local5 = ((int) callResult_2[0]); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local5); + arg1 = (local5 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 44, (int) 1); + local3 = ((local4 - local3) >> 3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) local3); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0)) != 0) { + break label_7; + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) local3); + callArgs_3[3] = ((long) (local2 + 8)); + callArgs_3[2] = ((long) (local2 + 24)); + callArgs_3[1] = ((long) 1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(245, callArgs_3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (((int) callResult_3[0]) + 36)); + break label_6; + } + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) (local2 + 40)); + callArgs_4[3] = ((long) (local2 + 8)); + callArgs_4[2] = ((long) (local2 + 24)); + callArgs_4[1] = ((long) (local2 + 44)); + callArgs_4[0] = ((long) (arg0 + 28)); + instance.getMachine().call(249, callArgs_4); + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_5; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local5); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_5); + } + label_8: { + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_8; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) local5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_6); + } + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_333(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_333(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_334(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + local2 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_2; + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) -4294967296L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local1); + callArgs_0[1] = ((long) 30367); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(246, callArgs_0); + arg0 = 1; + break label_1; + } + local3 = (((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 36) * 36) + local3) + -36); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) 12745); + callArgs_1[2] = ((long) 12745); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(288, callArgs_1); + arg0 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) local3 < 0 ? local3 : local3 + 0)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0]))); + } + instance.global(0).setValue(((long) (local1 + 16))); + return arg0; + } + + public static long[] call_334(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_334(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_335(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + local3 = (arg2 + 15); + memory.writeI32((int) (arg0 + 15) < 0 ? (arg0 + 15) : (arg0 + 15) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + local4 = (arg2 + 8); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (long) 0L); + local5 = (arg0 + 36); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 41476); + local6 = (arg0 + 32); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 36); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg1); + memory.writeLong((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0, (long) 0L); + memory.writeI32((int) (arg0 + 64) < 0 ? (arg0 + 64) : (arg0 + 64) + 0, (int) 0); + memory.writeLong((int) (arg0 + 68) < 0 ? (arg0 + 68) : (arg0 + 68) + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (arg0 + 83) < 0 ? (arg0 + 83) : (arg0 + 83) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + arg2 = (arg0 + 120); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 112, (int) 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 108, (byte) (0)); + memory.writeI32((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (int) -1); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 116, (int) arg2); + arg2 = (arg0 + 132); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 128, (int) arg2); + arg2 = (arg0 + 144); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 140, (int) arg2); + arg2 = (arg0 + 252); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 96); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) (arg0 + 152)); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 54); + arg1 = (arg0 + 264); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 248, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 260, (int) arg1); + arg2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 42068); + memory.writeI32((int) (arg0 + 280) < 0 ? (arg0 + 280) : (arg0 + 280) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 272, (long) 0L); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg0); + label_1: { + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + int ciTableIdx_1 = (int) (arg2); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + } + return arg0; + } + + public static long[] call_335(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_335(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_336(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local2); + callArgs_0[2] = ((long) 11317); + callArgs_0[1] = ((long) (arg0 + 88)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(337, callArgs_0); + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_336(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_336(arg0, arg1, memory, instance); + return null; + } + + public static int func_337(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local4)); + local5 = local4; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 148, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 144, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) (local5 + 16)); + local6 = (local5 + 16); + label_1: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) 128); + callArgs_0[0] = ((long) (local5 + 16)); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg3 = (((int) callResult_0[0]) + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, 129) != 0) { + break label_1; + } + local6 = (local4 - ((arg3 + 15) & -16)); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local6); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 144)); + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg3); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1875, callArgs_1); + } + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) 1); + label_2: { + label_3: { + label_4: { + arg3 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 8)) != 0) { + break label_4; + } + local4 = ((local5 + 152) + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + arg0 = ((local5 + 152) + 8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 152, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) 1); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 4, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 152)); + memory.writeLong((int) (arg3 + 12) < 0 ? (arg3 + 12) : (arg3 + 12) + 0, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeI32((int) (arg3 + 20) < 0 ? (arg3 + 20) : (arg3 + 20) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 2147483632) != 0) { + break label_2; + } + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 10) != 0) { + break label_6; + } + local4 = (arg3 + 24); + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 35, (byte) (arg1)); + break label_5; + } + arg0 = ((arg1 | 15) + 1); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local4 = ((int) callResult_3[0]); + memory.writeI32((int) (arg3 + 32) < 0 ? (arg3 + 32) : (arg3 + 32) + 0, (int) (arg0 | -2147483648)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 24, (int) local4); + memory.writeI32((int) (arg3 + 28) < 0 ? (arg3 + 28) : (arg3 + 28) + 0, (int) arg1); + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg1); + callArgs_4[1] = ((long) local6); + callArgs_4[0] = ((long) local4); + long[] callResult_4 = instance.getMachine().call(1891, callArgs_4); + memory.writeByte((int) (((int) callResult_4[0]) + arg1) < 0 ? (((int) callResult_4[0]) + arg1) : (((int) callResult_4[0]) + arg1) + 0, (byte) (0)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) (arg3 + 36)); + break label_3; + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local5 + 12)); + callArgs_5[2] = ((long) arg1); + callArgs_5[1] = ((long) (local5 + 8)); + callArgs_5[0] = ((long) arg2); + instance.getMachine().call(459, callArgs_5); + } + instance.global(0).setValue(((long) (local5 + 176))); + return 1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_337(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_337(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_338(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + local7 = 0; + local8 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg4, 2) != 0) { + break label_1; + } + local8 = 0; + if ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 7) & 0xFF) & 255) != 0) { + break label_1; + } + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 29132); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(337, callArgs_0); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 112); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 112, (int) (arg1 + 1)); + local9 = 0; + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg2, -1) != 0) { + break label_2; + } + local7 = (arg2 << 3); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local7); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local9 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local7); + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) local9); + long[] callResult_2 = instance.getMachine().call(1890, callArgs_2); + local7 = (((int) callResult_2[0]) + (arg2 << 3)); + } + local10 = 0; + arg2 = 0; + arg3 = 0; + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg4, -1) != 0) { + break label_2; + } + arg2 = (arg4 << 3); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg2); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg2); + callArgs_4[1] = ((long) arg5); + callArgs_4[0] = ((long) arg3); + long[] callResult_4 = instance.getMachine().call(1890, callArgs_4); + arg2 = (((int) callResult_4[0]) + (arg4 << 3)); + } + local11 = 0; + arg5 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, local7) != 0) { + break label_5; + } + arg4 = (local7 - local9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg4, -1) != 0) { + break label_2; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg4); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + arg5 = ((int) callResult_5[0]); + local7 = (((arg4 + -8) & -8) + 8); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local7); + callArgs_6[1] = ((long) local9); + callArgs_6[0] = ((long) arg5); + long[] callResult_6 = instance.getMachine().call(1890, callArgs_6); + local11 = ((int) callResult_6[0]); + local10 = (local11 + ((arg4 >> 3) << 3)); + local11 = (local11 + local7); + } + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg3, arg2) != 0) { + break label_7; + } + local12 = 0; + local13 = 0; + local14 = 0; + break label_6; + } + arg4 = (arg2 - arg3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg4, -1) != 0) { + break label_2; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg4); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + local12 = ((int) callResult_7[0]); + arg2 = (((arg4 + -8) & -8) + 8); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) arg2); + callArgs_8[1] = ((long) arg3); + callArgs_8[0] = ((long) local12); + long[] callResult_8 = instance.getMachine().call(1890, callArgs_8); + local7 = ((int) callResult_8[0]); + local14 = (local7 + ((arg4 >> 3) << 3)); + local13 = (local7 + arg2); + } + local7 = (arg0 + 120); + arg4 = local7; + label_8: { + label_9: { + label_10: { + arg2 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_10; + } + label_11: while (true) { + label_12: { + arg4 = arg2; + arg2 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, arg2) != 0) { + break label_12; + } + local7 = arg4; + arg2 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, arg1) != 0) { + break label_9; + } + arg2 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 4); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + local7 = (arg4 + 4); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) 48); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + arg2 = ((int) callResult_9[0]); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + memory.writeI32((int) (arg2 + 40) < 0 ? (arg2 + 40) : (arg2 + 40) + 0, (int) local14); + memory.writeI32((int) (arg2 + 36) < 0 ? (arg2 + 36) : (arg2 + 36) + 0, (int) local13); + memory.writeI32((int) (arg2 + 32) < 0 ? (arg2 + 32) : (arg2 + 32) + 0, (int) local12); + memory.writeI32((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (int) local10); + memory.writeI32((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (int) local11); + memory.writeI32((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0, (int) arg5); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) arg2); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 16, (int) arg1); + memory.writeI32((int) (arg2 + 44) < 0 ? (arg2 + 44) : (arg2 + 44) + 0, (int) arg6); + label_13: { + arg4 = memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 116) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 116) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 116) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_13; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 116, (int) arg4); + arg2 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) arg2); + callArgs_10[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 120)); + instance.getMachine().call(43, callArgs_10); + arg4 = (arg0 + 124); + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 0, (int) (memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0) + 1)); + break label_8; + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_14; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local12); + instance.getMachine().call(1777, callArgs_11); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg5) != 0) { + break label_8; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) arg5); + instance.getMachine().call(1777, callArgs_12); + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_15; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) arg3); + instance.getMachine().call(1777, callArgs_13); + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_16; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local9); + instance.getMachine().call(1777, callArgs_14); + } + return local8; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_338(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int result = Wat2WasmMachine.func_338(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_339(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 112); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 112, (int) (local4 + 1)); + local5 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + if (arg2 != 0) { + break label_5; + } + local6 = 0; + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 357913942) != 0) { + break label_1; + } + arg2 = (arg2 * 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg2); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local6 = ((int) callResult_0[0]); + arg2 = (((arg3 + arg2) - arg3) + -12); + arg2 = ((arg2 - com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg2, 12)) + 12); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg3); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1890, callArgs_1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S(arg2, 12); + if (arg2 != 0) { + break label_3; + } + } + local8 = 0; + local9 = 0; + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 357913942) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg2); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg3); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = instance.getMachine().call(1890, callArgs_3); + arg3 = ((int) callResult_3[0]); + local8 = (arg3 + arg2); + local9 = (arg3 + (local7 * 12)); + } + local7 = (arg0 + 132); + arg3 = local7; + label_6: { + label_7: { + label_8: { + arg2 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_8; + } + label_9: while (true) { + label_10: { + arg3 = arg2; + arg2 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, arg2) != 0) { + break label_10; + } + local7 = arg3; + arg2 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, local4) != 0) { + break label_7; + } + arg2 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + local7 = (arg3 + 4); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 32); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg2 = ((int) callResult_4[0]); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg3); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + memory.writeI32((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (int) local9); + memory.writeI32((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (int) local8); + memory.writeI32((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0, (int) local5); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) arg2); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 16, (int) local4); + label_11: { + arg3 = memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 128) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 128) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 128) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_11; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 128, (int) arg3); + arg2 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 132)); + instance.getMachine().call(43, callArgs_5); + arg3 = (arg0 + 136); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0) + 1)); + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_6; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_6); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_12; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_7); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_339(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_339(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_340(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 112); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 112, (int) (local3 + 1)); + local4 = (arg0 + 144); + local5 = local4; + label_1: { + label_2: { + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + label_3: while (true) { + label_4: { + local5 = local6; + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local6) != 0) { + break label_4; + } + local4 = local5; + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local3) != 0) { + break label_1; + } + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local4 = (local5 + 4); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 32); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local6 = ((int) callResult_0[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local5); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeLong((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeI32((int) (local6 + 28) < 0 ? (local6 + 28) : (local6 + 28) + 0, (int) memory.readInt((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local6); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) local3); + label_5: { + local5 = memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 140) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 140) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 140) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_5; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 140, (int) local5); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local6); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 144)); + instance.getMachine().call(43, callArgs_1); + local5 = (arg0 + 148); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 1)); + } + return 0; + } + + public static long[] call_340(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_340(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_341(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) (local3 + 64) < 0 ? (local3 + 64) : (local3 + 64) + 0, (long) 0L); + memory.writeLong((int) (local3 + 56) < 0 ? (local3 + 56) : (local3 + 56) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + arg2 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 48)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(342, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg2); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) (arg0 + 156) < 0 ? (arg0 + 156) : (arg0 + 156) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 160) < 0 ? (arg0 + 160) : (arg0 + 160) + 0), local5) != 0) { + break label_3; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) 0); + label_4: { + arg2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 52); + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, arg2) != 0) { + break label_4; + } + local6 = (arg2 - local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local6, -1) != 0) { + break label_1; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg2 = ((int) callResult_3[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) (arg2 + ((local6 >> 3) << 3))); + label_5: { + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + local7 = memory.readInt((int) local3 < 0 ? local3 : local3 + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local6) != 0) { + break label_5; + } + label_6: while (true) { + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + arg2 = (arg2 + 8); + local6 = (local6 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 12, (long) 0L); + memory.writeI32((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0, (int) 0); + label_7: { + local8 = memory.readInt((int) (local3 + 64) < 0 ? (local3 + 64) : (local3 + 64) + 0); + arg2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, local8) != 0) { + break label_7; + } + local6 = (local8 - arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local6, -1) != 0) { + break label_1; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg2 = ((int) callResult_4[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) (arg2 + ((local6 >> 3) << 3))); + label_8: { + local8 = memory.readInt((int) local3 < 0 ? local3 : local3 + 60); + local7 = memory.readInt((int) local3 < 0 ? local3 : local3 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local8) != 0) { + break label_8; + } + local6 = local8; + label_9: while (true) { + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + arg2 = (arg2 + 8); + local6 = (local6 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) arg2); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 72)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 156, (int) (local5 + 28)); + break label_2; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 48)); + callArgs_5[0] = ((long) (arg0 + 152)); + instance.getMachine().call(343, callArgs_5); + local8 = memory.readInt((int) local3 < 0 ? local3 : local3 + 60); + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_10; + } + memory.writeI32((int) (local3 + 64) < 0 ? (local3 + 64) : (local3 + 64) + 0, (int) local8); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local8); + instance.getMachine().call(1777, callArgs_6); + } + label_11: { + arg2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_11; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) arg2); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_7); + } + instance.global(0).setValue(((long) (local3 + 80))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_341(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_341(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_342(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local3 + 40)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 112); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local6) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) 15828); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local3 + 16)); + callArgs_2[2] = ((long) 30023); + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(337, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local5) != 0) { + break label_2; + } + label_4: { + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) local4); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_4); + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) 0); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + local4 = (arg2 + 12); + label_5: { + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_5; + } + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local5); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_5); + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) 0L); + local4 = 1; + break label_1; + } + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + label_6: { + label_7: { + local8 = (arg0 + 120); + local4 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_7; + } + local5 = local8; + label_8: while (true) { + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(memory.readInt((int) local4 < 0 ? local4 : local4 + 16), local7); + local5 = (local6 != 0 ? local5 : local4); + local6 = memory.readInt((int) (local6 != 0 ? (local4 + 4) : local4) < 0 ? (local6 != 0 ? (local4 + 4) : local4) : (local6 != 0 ? (local4 + 4) : local4) + 0); + local4 = local6; + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local5) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, memory.readInt((int) local5 < 0 ? local5 : local5 + 16)) != 0) { + break label_6; + } + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local7); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) local3); + callArgs_6[2] = ((long) 12331); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + local4 = ((int) callResult_6[0]); + break label_1; + } + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, (local5 + 20)) != 0) { + break label_9; + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0)); + callArgs_7[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 20)); + callArgs_7[0] = ((long) arg2); + instance.getMachine().call(344, callArgs_7); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) memory.readInt((int) (local5 + 36) < 0 ? (local5 + 36) : (local5 + 36) + 0)); + callArgs_8[1] = ((long) memory.readInt((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0)); + callArgs_8[0] = ((long) (arg2 + 12)); + instance.getMachine().call(344, callArgs_8); + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 24, (int) memory.readInt((int) (local5 + 44) < 0 ? (local5 + 44) : (local5 + 44) + 0)); + } + instance.global(0).setValue(((long) (local3 + 80))); + return local4; + } + + public static long[] call_342(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_342(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_343(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2), 28); + local4 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 153391690) != 0) { + break label_4; + } + label_5: { + label_6: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 28); + local5 = (local2 << 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 76695844) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, local4) != 0 ? local5 : local4) : 153391689); + if (local4 != 0) { + break label_6; + } + local2 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 153391690) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 * 28)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + } + local6 = (local2 + (local4 * 28)); + local7 = (local2 + (local3 * 28)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) local7); + long[] callResult_1 = instance.getMachine().call(446, callArgs_1); + local4 = ((int) callResult_1[0]); + local8 = (local4 + 28); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, local3) != 0) { + break label_2; + } + arg1 = 0; + label_7: while (true) { + local4 = (local7 + arg1); + local5 = (local4 + -28); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + local10 = (local4 + -20); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) 0); + local2 = (local3 + arg1); + local11 = (local2 + -28); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local11 < 0 ? local11 : local11 + 0)); + local5 = (local2 + -20); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + local5 = (local4 + -16); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + local10 = (local4 + -8); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) 0); + local11 = (local2 + -16); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local11 < 0 ? local11 : local11 + 0)); + local5 = (local2 + -8); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + memory.writeI32((int) (local4 + -4) < 0 ? (local4 + -4) : (local4 + -4) + 0, (int) memory.readInt((int) (local2 + -4) < 0 ? (local2 + -4) : (local2 + -4) + 0)); + arg1 = (arg1 + -28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, (local3 + arg1)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local7 + arg1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_1; + } + local4 = (local4 + -28); + label_8: while (true) { + label_9: { + local2 = memory.readInt((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_9; + } + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) local2); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + } + label_10: { + local2 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_10; + } + memory.writeI32((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (int) local2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local4); + local4 = (local4 + -28); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local4); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_11; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_6); + } + return; + } + + public static long[] call_343(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_343(arg0, arg1, memory, instance); + return null; + } + + public static void func_344(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + local3 = (arg2 - arg1); + local4 = (local3 >> 3); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, ((local5 - local6) >> 3)) != 0) { + break label_1; + } + label_2: { + local5 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local6); + local7 = (local5 >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local4, local7) != 0) { + break label_2; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local5); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + label_3: { + arg1 = (arg1 + (local7 << 3)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg1) != 0) { + break label_3; + } + label_4: while (true) { + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local6 = (local6 + 8); + arg1 = (arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + return; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1891, callArgs_1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (((int) callResult_1[0]) + (local4 << 3))); + return; + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_5; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_2); + local5 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local3, -1) != 0) { + break label_6; + } + local6 = (local5 >>> 2); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local4) != 0 ? local6 : local4) : 536870911); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 536870912) != 0) { + break label_6; + } + local4 = (local6 << 3); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local6 = ((int) callResult_3[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local6 + local4)); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg1) != 0) { + break label_7; + } + arg2 = (((local3 + -8) & -8) + 8); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg2); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1890, callArgs_4); + local6 = (((int) callResult_4[0]) + arg2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_344(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_344(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_345(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + long local8 = 0L; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local4)); + local5 = 0; + local6 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164), memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0)) != 0) { + break label_1; + } + local6 = 0; + if ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 10) & 0xFF) & 255) != 0) { + break label_1; + } + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 18659); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(337, callArgs_0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])); + } + label_2: { + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local7, 4294967296L) != 0) { + break label_2; + } + memory.writeLong((int) (local4 + 80) < 0 ? (local4 + 80) : (local4 + 80) + 0, (long) 4294967295L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 72, (long) local7); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 64, (int) 8121); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local4 + 64)); + callArgs_1[2] = ((long) 29875); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg3 < 0 ? arg3 : arg3 + 16) & 0xFF)) != 0) { + break label_3; + } + label_4: { + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local7, 4294967296L) != 0) { + break label_4; + } + memory.writeLong((int) (local4 + 48) < 0 ? (local4 + 48) : (local4 + 48) + 0, (long) 4294967295L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local7); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 8121); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local4 + 32)); + callArgs_2[2] = ((long) 29843); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(337, callArgs_2); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0]))); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 8); + } + local8 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(local7, local8) != 0) { + break label_3; + } + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) local8); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) 8121); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local7); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 8121); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local4); + callArgs_3[2] = ((long) 29800); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(337, callArgs_3); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0]))); + } + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (local6 | local5)); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg3 < 0 ? arg3 : arg3 + 17) & 0xFF)) != 0) { + break label_5; + } + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) 0); + callArgs_4[2] = ((long) 18819); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(337, callArgs_4); + local9 = (local9 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0]))); + } + label_6: { + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-16, local5) != 0) { + break label_6; + } + label_7: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 10) & 0xFF) != 0) { + break label_7; + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) 0); + callArgs_5[2] = ((long) 16127); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local9 = (local9 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0]))); + } + label_8: { + local5 = (local5 + 23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 6) != 0) { + break label_8; + } + if (((1 << local5) & 69) != 0) { + break label_6; + } + } + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) 0); + callArgs_6[2] = ((long) 8508); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local9) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_6[0]))); + } + arg1 = ((local4 + 88) + 8); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + local6 = ((local4 + 88) + 16); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 88, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + label_9: { + label_10: { + label_11: { + label_12: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 168); + arg2 = memory.readInt((int) (arg0 + 172) < 0 ? (arg0 + 172) : (arg0 + 172) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, arg2) != 0) { + break label_12; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 88)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) local7); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 168, (int) (local5 + 32)); + break label_11; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164); + local10 = ((local5 - local6) >> 5); + arg1 = (local10 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 134217728) != 0) { + break label_10; + } + label_13: { + label_14: { + arg2 = (arg2 - local6); + local11 = (arg2 >>> 4); + arg2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 2147483616) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local11, arg1) != 0 ? local11 : arg1) : 134217727); + if (arg2 != 0) { + break label_14; + } + local11 = 0; + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 134217728) != 0) { + break label_9; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) (arg2 << 5)); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + local11 = ((int) callResult_7[0]); + } + arg1 = (local11 + (local10 << 5)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local7); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 8, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (long) memory.readLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) memory.readLong((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0)); + arg3 = (local11 + (arg2 << 5)); + arg2 = (arg1 + 32); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local5) != 0) { + break label_15; + } + label_16: while (true) { + arg1 = (arg1 + -32); + local5 = (local5 + -32); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) memory.readLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0)); + memory.writeLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (long) memory.readLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + memory.writeLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (long) memory.readLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 172, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 168, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 164, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_11; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local4 + 112))); + return local9; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_345(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_345(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_346(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + long local8 = 0L; + long local9 = 0L; + long local10 = 0L; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local4 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local4)); + local5 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 176), memory.readInt((int) (arg0 + 180) < 0 ? (arg0 + 180) : (arg0 + 180) + 0)) != 0) { + break label_1; + } + if ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15) & 0xFF) & 255) != 0) { + break label_1; + } + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 18584); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(337, callArgs_0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(65536, arg3) != 0) { + break label_2; + } + label_3: { + label_4: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 18) & 0xFF) != 0) { + break label_4; + } + local6 = 18509; + break label_3; + } + local6 = 18614; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3) != 0) { + break label_2; + } + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0]))); + } + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(arg3)) != 0) { + break label_6; + } + local6 = 0; + label_7: { + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + local8 = (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 18) & 0xFF) != 0 ? -1L : 4294967295L); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg3); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I64_DIV_U(local8, local9); + local8 = (local10 + com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(local8, (local10 * local9)))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local7, local8) != 0) { + break label_7; + } + memory.writeLong((int) (local4 + 80) < 0 ? (local4 + 80) : (local4 + 80) + 0, (long) local8); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 72, (long) local7); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 64, (int) 8673); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local4 + 64)); + callArgs_2[2] = ((long) 29875); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(337, callArgs_2); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])); + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 16) & 0xFF)) != 0) { + break label_8; + } + label_9: { + local9 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local9, local8) != 0) { + break label_9; + } + memory.writeLong((int) (local4 + 48) < 0 ? (local4 + 48) : (local4 + 48) + 0, (long) local8); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 8673); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) (local4 + 32)); + callArgs_3[2] = ((long) 29843); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(337, callArgs_3); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local6) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0]))); + local9 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 8); + } + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(local9, local8) != 0) { + break label_8; + } + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) local8); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) 8673); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 8673); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local4); + callArgs_4[2] = ((long) 29800); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(337, callArgs_4); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local6) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0]))); + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (local5 | local6)); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 17) & 0xFF)) != 0) { + break label_10; + } + label_11: { + label_12: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 5) & 0xFF) != 0) { + break label_12; + } + arg3 = 18844; + break label_11; + } + if (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 16) & 0xFF) != 0) { + break label_10; + } + arg3 = 8360; + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) 0); + callArgs_5[2] = ((long) arg3); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local5 = (local5 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0]))); + } + label_13: { + label_14: { + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 180); + local6 = memory.readInt((int) (arg0 + 184) < 0 ? (arg0 + 184) : (arg0 + 184) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, local6) != 0) { + break label_14; + } + local8 = memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0); + local9 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0, (long) memory.readLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + memory.writeLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (long) local8); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 180, (int) (arg3 + 24)); + break label_13; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 176); + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg3 - arg1), 24); + local12 = (local11 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local12, 178956971) != 0) { + break label_6; + } + label_15: { + label_16: { + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - arg1), 24); + local13 = (local6 << 1); + local12 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 89478485) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local13, local12) != 0 ? local13 : local12) : 178956970); + if (local12 != 0) { + break label_16; + } + local13 = 0; + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local12, 178956971) != 0) { + break label_5; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) (local12 * 24)); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + local13 = ((int) callResult_6[0]); + } + local6 = (local13 + (local11 * 24)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) memory.readLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + arg2 = (local13 + (local12 * 24)); + local12 = (local6 + 24); + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg3) != 0) { + break label_17; + } + label_18: while (true) { + local6 = (local6 + -24); + arg3 = (arg3 + -24); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) memory.readLong((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 176); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 184, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 180, (int) local12); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 176, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_13; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg3); + instance.getMachine().call(1777, callArgs_7); + } + instance.global(0).setValue(((long) (local4 + 96))); + return local5; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_346(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_346(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_347(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + long local5 = 0L; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local4 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_1; + } + if ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 255) != 0) { + break label_1; + } + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 18784); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(337, callArgs_0); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])); + } + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + label_2: { + label_3: { + label_4: { + label_5: { + arg2 = memory.readInt((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0); + arg1 = memory.readInt((int) (arg0 + 196) < 0 ? (arg0 + 196) : (arg0 + 196) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, arg1) != 0) { + break label_5; + } + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 8, (byte) (arg3)); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 192, (int) (arg2 + 12)); + break label_4; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 188); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg2 - local6), 12); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 357913942) != 0) { + break label_3; + } + label_6: { + label_7: { + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local6), 12); + local9 = (arg1 << 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 357913941); + if (local8 != 0) { + break label_7; + } + local9 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 357913942) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local8 * 12)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local9 = ((int) callResult_1[0]); + } + arg1 = (local9 + (local7 * 12)); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 8, (byte) (arg3)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local5); + arg3 = (local9 + (local8 * 12)); + local8 = (arg1 + 12); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, arg2) != 0) { + break label_8; + } + label_9: while (true) { + arg1 = (arg1 + -12); + arg2 = (arg2 + -12); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeByte((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (byte) (((int) memory.read((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 188); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 196, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 192, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 188, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_4; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 228, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 228) + 1)); + return local4; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_347(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_347(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_348(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long local4 = 0L; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local4 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + label_1: { + arg2 = memory.readInt((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0); + local5 = memory.readInt((int) (arg0 + 196) < 0 ? (arg0 + 196) : (arg0 + 196) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, local5) != 0) { + break label_1; + } + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 8, (byte) (arg3)); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 192, (int) (arg2 + 12)); + return 0; + } + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 188); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg2 - local6), 12); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 357913942) != 0) { + break label_3; + } + label_4: { + label_5: { + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local6), 12); + local9 = (local5 << 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 357913941); + if (local8 != 0) { + break label_5; + } + local9 = 0; + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 357913942) != 0) { + break label_2; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local8 * 12)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local9 = ((int) callResult_0[0]); + } + local5 = (local9 + (local7 * 12)); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 8, (byte) (arg3)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) local4); + arg3 = (local9 + (local8 * 12)); + local8 = (local5 + 12); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, arg2) != 0) { + break label_6; + } + label_7: while (true) { + local5 = (local5 + -12); + arg2 = (arg2 + -12); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeByte((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (byte) (((int) memory.read((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 188); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 196, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 192, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 188, (int) local5); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_8; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_1); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_348(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_348(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_349(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + long local6 = 0L; + long local7 = 0L; + int local8 = 0; + local5 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local5)); + local6 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 72, (long) local6); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 16, (long) local7); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 24, (long) local6); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 64, (long) local7); + local8 = 0; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local5 + 16)); + callArgs_0[0] = ((long) (local5 + 24)); + long[] callResult_0 = instance.getMachine().call(250, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 48)); + instance.getMachine().call(38, callArgs_1); + arg2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + local8 = (int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 59); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local5 + 32)); + instance.getMachine().call(38, callArgs_2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0) != 0 ? arg2 : (local5 + 48))); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 43), 0) != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 32) : (local5 + 32))); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local5); + callArgs_3[2] = ((long) 10700); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(337, callArgs_3); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 43), -1) != 0) { + break label_2; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 32)); + instance.getMachine().call(1777, callArgs_4); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 59), -1) != 0) { + break label_3; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 48)); + instance.getMachine().call(1777, callArgs_5); + } + local8 = 1; + } + instance.global(0).setValue(((long) (local5 + 80))); + return local8; + } + + public static long[] call_349(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_349(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_350(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local3)); + local4 = (local3 + 80); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeLong((int) (local3 + 72) < 0 ? (local3 + 72) : (local3 + 72) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) 0L); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (local3 + 24)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + arg2 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 64)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(342, callArgs_1); + local5 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg2); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) local4 < 0 ? local4 : local4 + 0), memory.readInt((int) local3 < 0 ? local3 : local3 + 76)) != 0) { + break label_2; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5); + break label_1; + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) 0); + callArgs_3[2] = ((long) 28931); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(337, callArgs_3); + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0]))); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) 0L); + label_3: { + label_4: { + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 68); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local5) != 0) { + break label_4; + } + local6 = (local5 - local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local6, -1) != 0) { + break label_3; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg2 = ((int) callResult_4[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) (arg2 + ((local6 >> 3) << 3))); + label_5: while (true) { + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + arg2 = (arg2 + 8); + local4 = (local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg2); + } + label_6: { + label_7: { + arg2 = memory.readInt((int) (arg0 + 204) < 0 ? (arg0 + 204) : (arg0 + 204) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, memory.readInt((int) (arg0 + 208) < 0 ? (arg0 + 208) : (arg0 + 208) + 0)) != 0) { + break label_7; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 8)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 204, (int) (arg2 + 12)); + break label_6; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 8)); + callArgs_5[0] = ((long) (arg0 + 200)); + instance.getMachine().call(351, callArgs_5); + arg2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_6; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg2); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_6); + } + label_8: { + arg2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_8; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 80, (int) arg2); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_7); + } + label_9: { + arg2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_9; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 68, (int) arg2); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local3 + 96))); + return arg1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_350(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_350(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_351(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + int local8 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2), 12); + local4 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 357913942) != 0) { + break label_4; + } + local5 = 0; + label_5: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 12); + local6 = (local2 << 1); + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local4) != 0 ? local6 : local4) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 357913942) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local2 * 12)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local5 = ((int) callResult_0[0]); + } + local7 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) 0); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + local4 = (local5 + (local3 * 12)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local6); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) local7); + local6 = (local5 + (local2 * 12)); + local8 = (local4 + 12); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + label_6: while (true) { + local2 = (local4 + -12); + arg1 = (local5 + -12); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local5 = (local5 + -4); + memory.writeI32((int) (local4 + -4) < 0 ? (local4 + -4) : (local4 + -4) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + local5 = arg1; + local4 = local2; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, arg1) != 0) { + break label_1; + } + arg1 = (arg1 + -12); + label_7: while (true) { + label_8: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_8; + } + memory.writeI32((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0, (int) local4); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_1); + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, arg1); + arg1 = (arg1 + -12); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local4); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_9; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_4); + } + return; + } + + public static long[] call_351(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_351(arg0, arg1, memory, instance); + return null; + } + + public static int func_352(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local5 = (((int) instance.global(0).getValue()) - 368); + instance.global(0).setValue(((long) local5)); + label_1: { + local6 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 2147483632) != 0) { + break label_1; + } + arg4 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 10) != 0) { + break label_3; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 283, (byte) (local6)); + local7 = (local5 + 272); + break label_2; + } + local8 = ((local6 | 15) + 1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local8); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 280, (int) (local8 | -2147483648)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 272, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 276, (int) local6); + } + local8 = 0; + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) arg4); + callArgs_1[0] = ((long) local7); + long[] callResult_1 = instance.getMachine().call(1891, callArgs_1); + memory.writeByte((int) (((int) callResult_1[0]) + local6) < 0 ? (((int) callResult_1[0]) + local6) : (((int) callResult_1[0]) + local6) + 0, (byte) (0)); + label_4: { + local7 = (arg0 + 248); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 272)); + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(353, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((arg0 + 252), ((int) callResult_2[0])) != 0) { + break label_4; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 68, (int) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 64, (int) local6); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) (local5 + 64)); + callArgs_3[2] = ((long) 30709); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(337, callArgs_3); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])); + } + label_5: { + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local5 + 272)); + callArgs_4[1] = ((long) (local5 + 328)); + callArgs_4[0] = ((long) local7); + long[] callResult_4 = instance.getMachine().call(354, callArgs_4); + arg4 = ((int) callResult_4[0]); + if (memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0) != 0) { + break label_5; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 28); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + local6 = ((int) callResult_5[0]); + arg1 = (local6 + 16); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 283), 0) != 0) { + break label_7; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 272)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) ((local5 + 272) + 8) < 0 ? ((local5 + 272) + 8) : ((local5 + 272) + 8) + 0)); + break label_6; + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 276)); + callArgs_6[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 272)); + callArgs_6[0] = ((long) arg1); + instance.getMachine().call(1647, callArgs_6); + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 328)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 0, (int) local6); + label_8: { + arg1 = memory.readInt((int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0) < 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 0) : memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_8; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) arg1); + local6 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0); + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local6); + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 252)); + instance.getMachine().call(43, callArgs_7); + local6 = (arg0 + 256); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 1)); + } + label_9: { + label_10: { + label_11: { + label_12: { + label_13: { + label_14: { + switch(arg2) { + case 0: + { + break label_14; + } + case 1: + { + break label_13; + } + case 2: + { + break label_12; + } + case 3: + { + break label_11; + } + case 4: + { + break label_10; + } + default: + { + break label_9; + } + } + } + label_15: { + label_16: { + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) arg3); + callArgs_8[0] = ((long) (local5 + 232)); + long[] callResult_8 = instance.getMachine().call(159, callArgs_8); + arg4 = ((int) callResult_8[0]); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) arg4); + callArgs_9[0] = ((long) (local5 + 288)); + long[] callResult_9 = instance.getMachine().call(159, callArgs_9); + local7 = ((int) callResult_9[0]); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) local7); + callArgs_10[0] = ((long) (local5 + 328)); + long[] callResult_10 = instance.getMachine().call(159, callArgs_10); + local6 = ((int) callResult_10[0]); + arg2 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 156) < 0 ? (arg0 + 156) : (arg0 + 156) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 152)), 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, arg1) != 0) { + break label_16; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 12348); + long[] callArgs_11 = new long[4]; + callArgs_11[3] = ((long) local5); + callArgs_11[2] = ((long) 30023); + callArgs_11[1] = ((long) local6); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(337, callArgs_11); + arg2 = ((int) callResult_11[0]); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local6); + long[] callResult_12 = instance.getMachine().call(162, callArgs_12); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2); + break label_15; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local6); + long[] callResult_13 = instance.getMachine().call(162, callArgs_13); + local6 = 0; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local7); + long[] callResult_14 = instance.getMachine().call(162, callArgs_14); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) arg4); + long[] callResult_15 = instance.getMachine().call(162, callArgs_15); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local8) | local6); + local7 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 24); + arg3 = (arg0 + 264); + local6 = arg3; + label_17: { + arg4 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_17; + } + label_18: while (true) { + label_19: { + local6 = arg4; + arg4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, arg4) != 0) { + break label_19; + } + arg3 = local6; + arg4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + if (arg4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break label_17; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg4, local7) != 0) { + break label_9; + } + arg4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + if (arg4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + arg3 = (local6 + 4); + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) 20); + long[] callResult_16 = instance.getMachine().call(1776, callArgs_16); + arg4 = ((int) callResult_16[0]); + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 8, (int) local6); + memory.writeLong((int) arg4 < 0 ? arg4 : arg4 + 0, (long) 0L); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg4); + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 16, (int) local7); + label_20: { + local6 = memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 260) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 260) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 260) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_20; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 260, (int) local6); + arg4 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) arg4); + callArgs_17[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 264)); + instance.getMachine().call(43, callArgs_17); + arg0 = (arg0 + 268); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 1)); + break label_9; + } + label_21: { + label_22: { + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) arg3); + callArgs_18[0] = ((long) (local5 + 192)); + long[] callResult_18 = instance.getMachine().call(159, callArgs_18); + arg4 = ((int) callResult_18[0]); + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) arg4); + callArgs_19[0] = ((long) (local5 + 288)); + long[] callResult_19 = instance.getMachine().call(159, callArgs_19); + local7 = ((int) callResult_19[0]); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) local7); + callArgs_20[0] = ((long) (local5 + 328)); + long[] callResult_20 = instance.getMachine().call(159, callArgs_20); + local6 = ((int) callResult_20[0]); + arg3 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + arg2 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, arg2) != 0) { + break label_22; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) 17326); + long[] callArgs_21 = new long[4]; + callArgs_21[3] = ((long) (local5 + 16)); + callArgs_21[2] = ((long) 30023); + callArgs_21[1] = ((long) local6); + callArgs_21[0] = ((long) arg0); + long[] callResult_21 = instance.getMachine().call(337, callArgs_21); + arg0 = ((int) callResult_21[0]); + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) local6); + long[] callResult_22 = instance.getMachine().call(162, callArgs_22); + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0); + break label_21; + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) local6); + long[] callResult_23 = instance.getMachine().call(162, callArgs_23); + arg0 = 0; + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) local7); + long[] callResult_24 = instance.getMachine().call(162, callArgs_24); + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) arg4); + long[] callResult_25 = instance.getMachine().call(162, callArgs_25); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local8) | arg0); + break label_9; + } + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) arg3); + callArgs_26[0] = ((long) (local5 + 152)); + long[] callResult_26 = instance.getMachine().call(159, callArgs_26); + local6 = ((int) callResult_26[0]); + long[] callArgs_27 = new long[3]; + callArgs_27[2] = ((long) 0); + callArgs_27[1] = ((long) local6); + callArgs_27[0] = ((long) arg0); + long[] callResult_27 = instance.getMachine().call(355, callArgs_27); + arg0 = ((int) callResult_27[0]); + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) local6); + long[] callResult_28 = instance.getMachine().call(162, callArgs_28); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + break label_9; + } + label_23: { + label_24: { + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) arg3); + callArgs_29[0] = ((long) (local5 + 112)); + long[] callResult_29 = instance.getMachine().call(159, callArgs_29); + arg4 = ((int) callResult_29[0]); + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) arg4); + callArgs_30[0] = ((long) (local5 + 288)); + long[] callResult_30 = instance.getMachine().call(159, callArgs_30); + local7 = ((int) callResult_30[0]); + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) local7); + callArgs_31[0] = ((long) (local5 + 328)); + long[] callResult_31 = instance.getMachine().call(159, callArgs_31); + local6 = ((int) callResult_31[0]); + arg3 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 188)), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, arg2) != 0) { + break label_24; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 36, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 32, (int) 13761); + long[] callArgs_32 = new long[4]; + callArgs_32[3] = ((long) (local5 + 32)); + callArgs_32[2] = ((long) 30023); + callArgs_32[1] = ((long) local6); + callArgs_32[0] = ((long) arg0); + long[] callResult_32 = instance.getMachine().call(337, callArgs_32); + arg0 = ((int) callResult_32[0]); + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) local6); + long[] callResult_33 = instance.getMachine().call(162, callArgs_33); + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0); + break label_23; + } + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) local6); + long[] callResult_34 = instance.getMachine().call(162, callArgs_34); + arg0 = 0; + } + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) local7); + long[] callResult_35 = instance.getMachine().call(162, callArgs_35); + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) arg4); + long[] callResult_36 = instance.getMachine().call(162, callArgs_36); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local8) | arg0); + break label_9; + } + label_25: { + label_26: { + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) arg3); + callArgs_37[0] = ((long) (local5 + 72)); + long[] callResult_37 = instance.getMachine().call(159, callArgs_37); + arg4 = ((int) callResult_37[0]); + long[] callArgs_38 = new long[2]; + callArgs_38[1] = ((long) arg4); + callArgs_38[0] = ((long) (local5 + 288)); + long[] callResult_38 = instance.getMachine().call(159, callArgs_38); + local7 = ((int) callResult_38[0]); + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) local7); + callArgs_39[0] = ((long) (local5 + 328)); + long[] callResult_39 = instance.getMachine().call(159, callArgs_39); + local6 = ((int) callResult_39[0]); + arg3 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 204) < 0 ? (arg0 + 204) : (arg0 + 204) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 200)), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, arg2) != 0) { + break label_26; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 56, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 52, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 48, (int) 14710); + long[] callArgs_40 = new long[4]; + callArgs_40[3] = ((long) (local5 + 48)); + callArgs_40[2] = ((long) 30023); + callArgs_40[1] = ((long) local6); + callArgs_40[0] = ((long) arg0); + long[] callResult_40 = instance.getMachine().call(337, callArgs_40); + arg0 = ((int) callResult_40[0]); + long[] callArgs_41 = new long[1]; + callArgs_41[0] = ((long) local6); + long[] callResult_41 = instance.getMachine().call(162, callArgs_41); + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0); + break label_25; + } + long[] callArgs_42 = new long[1]; + callArgs_42[0] = ((long) local6); + long[] callResult_42 = instance.getMachine().call(162, callArgs_42); + arg0 = 0; + } + long[] callArgs_43 = new long[1]; + callArgs_43[0] = ((long) local7); + long[] callResult_43 = instance.getMachine().call(162, callArgs_43); + long[] callArgs_44 = new long[1]; + callArgs_44[0] = ((long) arg4); + long[] callResult_44 = instance.getMachine().call(162, callArgs_44); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local8) | arg0); + } + label_27: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 283), -1) != 0) { + break label_27; + } + long[] callArgs_45 = new long[1]; + callArgs_45[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 272)); + instance.getMachine().call(1777, callArgs_45); + } + instance.global(0).setValue(((long) (local5 + 368))); + return local8; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_352(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_352(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_353(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (arg0 + 4); + label_1: { + label_2: { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + local3 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11) & 0xFF); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local3 = (local4 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : local3); + local5 = (local4 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : arg1); + local6 = local2; + label_3: while (true) { + label_4: { + label_5: { + arg1 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27) & 0xFF); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0); + arg1 = (local4 != 0 ? memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0) : arg1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, arg1); + local8 = (local7 != 0 ? local3 : arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_5; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local8); + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) (local4 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) : (arg0 + 16))); + long[] callResult_0 = instance.getMachine().call(1889, callArgs_0); + local4 = ((int) callResult_0[0]); + if (local4 != 0) { + break label_4; + } + } + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, local3) != 0 ? -1 : local7); + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0); + local6 = (arg1 != 0 ? local6 : arg0); + arg1 = memory.readInt((int) (arg1 != 0 ? (arg0 + 4) : arg0) < 0 ? (arg1 != 0 ? (arg0 + 4) : arg0) : (arg1 != 0 ? (arg0 + 4) : arg0) + 0); + arg0 = arg1; + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local6) != 0) { + break label_2; + } + label_6: { + label_7: { + arg0 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 27) & 0xFF); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0); + arg0 = (arg1 != 0 ? memory.readInt((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0) : arg0); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, local3) != 0 ? arg0 : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_7; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) (arg1 != 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 16) : (local6 + 16))); + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1889, callArgs_1); + arg1 = ((int) callResult_1[0]); + if (arg1 != 0) { + break label_6; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, arg0) != 0) { + break label_2; + } + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg1, -1) != 0) { + break label_1; + } + } + local6 = local2; + } + return local6; + } + + public static long[] call_353(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_353(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_354(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = (arg0 + 4); + label_1: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (local4 != 0) { + break label_1; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + return local3; + } + arg0 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 11) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), -1); + local6 = (local5 != 0 ? arg2 : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + arg0 = (local5 != 0 ? arg0 : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4)); + label_2: { + label_3: while (true) { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + arg2 = local4; + local4 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 27) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + local4 = (local7 != 0 ? memory.readInt((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0) : local4); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, arg0); + local5 = (local8 != 0 ? local4 : arg0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_9; + } + label_10: { + local9 = (local7 != 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 16) : (arg2 + 16)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local5); + callArgs_0[1] = ((long) local9); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1889, callArgs_0); + local7 = ((int) callResult_0[0]); + if (local7 != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, local4) != 0) { + break label_8; + } + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local7, -1) != 0) { + break label_7; + } + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, local4) != 0) { + break label_6; + } + } + local3 = arg2; + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break label_2; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) local6); + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1889, callArgs_1); + local4 = ((int) callResult_1[0]); + if (local4 != 0) { + break label_5; + } + } + if (local8 != 0) { + break label_4; + } + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local4, -1) != 0) { + break label_2; + } + } + local3 = (arg2 + 4); + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) arg2); + return local3; + } + + public static long[] call_354(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_354(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_355(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local3 + 24)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) (local3 + 88)); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + arg1 = ((int) callResult_1[0]); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 180) < 0 ? (arg0 + 180) : (arg0 + 180) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 176)), 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local6) != 0) { + break label_5; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 1196); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) 30023); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(337, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + if (local5 != 0) { + break label_4; + } + break label_3; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + if (arg2 != 0) { + break label_3; + } + local5 = 0; + break label_1; + } + memory.writeLong((int) (local3 + 80) < 0 ? (local3 + 80) : (local3 + 80) + 0, (long) 0L); + memory.writeLong((int) (local3 + 72) < 0 ? (local3 + 72) : (local3 + 72) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) 0L); + break label_2; + } + arg0 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 176) + (memory.readInt((int) local4 < 0 ? local4 : local4 + 24) * 24)); + memory.writeLong((int) ((local3 + 64) + 8) < 0 ? ((local3 + 64) + 8) : ((local3 + 64) + 8) + 0, (long) memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0)); + memory.writeLong((int) ((local3 + 64) + 16) < 0 ? ((local3 + 64) + 16) : ((local3 + 64) + 16) + 0, (long) memory.readLong((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + local5 = 0; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 64)); + memory.writeLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (long) memory.readLong((int) ((local3 + 64) + 16) < 0 ? ((local3 + 64) + 16) : ((local3 + 64) + 16) + 0)); + memory.writeLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (long) memory.readLong((int) ((local3 + 64) + 8) < 0 ? ((local3 + 64) + 8) : ((local3 + 64) + 8) + 0)); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 128))); + return local5; + } + + public static long[] call_355(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_355(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_356(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local5 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local5 + 56)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local6 = ((int) callResult_0[0]); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) - memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)), 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, local8) != 0) { + break label_6; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg4); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local5); + callArgs_1[2] = ((long) 30023); + callArgs_1[1] = ((long) local6); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + arg4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_2; + } + if (arg4 != 0) { + break label_5; + } + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + if (arg3 != 0) { + break label_4; + } + arg4 = 0; + break label_2; + } + arg0 = 0; + memory.writeI32((int) (local5 + 48) < 0 ? (local5 + 48) : (local5 + 48) + 0, (int) 0); + memory.writeLong((int) (local5 + 40) < 0 ? (local5 + 40) : (local5 + 40) + 0, (long) 0L); + memory.writeLong((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (long) 0L); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 24, (long) 0L); + arg2 = 0; + local6 = 0; + local7 = 0; + break label_3; + } + arg0 = 0; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local6 = 0; + local7 = 0; + label_7: { + local8 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local9 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + arg4 = (local8 + (local9 * 28)); + arg2 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 4); + arg1 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_7; + } + local6 = (arg2 - arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local6, -1) != 0) { + break label_1; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local7 = ((int) callResult_4[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 32, (int) (local7 + ((local6 >> 3) << 3))); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + local6 = local7; + label_8: { + arg2 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0); + arg1 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_8; + } + local6 = local7; + label_9: while (true) { + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + local6 = (local6 + 8); + arg2 = (arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) local6); + } + memory.writeI32((int) (local5 + 44) < 0 ? (local5 + 44) : (local5 + 44) + 0, (int) 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 36, (long) 0L); + label_10: { + local10 = (arg4 + 16); + arg2 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + arg1 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_10; + } + arg2 = (arg2 - arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg2, -1) != 0) { + break label_1; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg2); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + arg0 = ((int) callResult_5[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 44, (int) (arg0 + ((arg2 >> 3) << 3))); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 36, (int) arg0); + arg2 = arg0; + label_11: { + arg1 = memory.readInt((int) (arg4 + 12) < 0 ? (arg4 + 12) : (arg4 + 12) + 0); + arg4 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg4, arg1) != 0) { + break label_11; + } + arg2 = arg0; + label_12: while (true) { + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + arg2 = (arg2 + 8); + arg1 = (arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg4, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg2); + } + arg2 = memory.readInt((int) (local8 + (local9 * 28)) < 0 ? (local8 + (local9 * 28)) : (local8 + (local9 * 28)) + 24); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 48, (int) arg2); + arg4 = 0; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg3, (local5 + 24)) != 0) { + break label_13; + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local6); + callArgs_6[1] = ((long) local7); + callArgs_6[0] = ((long) arg3); + instance.getMachine().call(344, callArgs_6); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) memory.readInt((int) (local5 + 40) < 0 ? (local5 + 40) : (local5 + 40) + 0)); + callArgs_7[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 36)); + callArgs_7[0] = ((long) (arg3 + 12)); + instance.getMachine().call(344, callArgs_7); + arg0 = memory.readInt((int) local5 < 0 ? local5 : local5 + 36); + arg2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + } + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 24, (int) arg2); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_14; + } + memory.writeI32((int) (local5 + 40) < 0 ? (local5 + 40) : (local5 + 40) + 0, (int) arg0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_8); + } + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) local6); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_9); + } + instance.global(0).setValue(((long) (local5 + 96))); + return arg4; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_356(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_356(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_357(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + label_4: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local3 + 16)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) (local3 + 56)); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + arg1 = ((int) callResult_1[0]); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 188)), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local6) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 13761); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) 30023); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(337, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + arg1 = 1; + local6 = -1; + arg0 = 0; + break label_2; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + if (arg2 != 0) { + break label_3; + } + local5 = 0; + break label_1; + } + arg0 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 188) + (memory.readInt((int) local4 < 0 ? local4 : local4 + 24) * 12)); + arg1 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 8) & 0xFF); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = 0; + } + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 8, (byte) (arg1)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) local6); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg0); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 96))); + return local5; + } + + public static long[] call_357(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_357(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_358(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local5 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local5 + 24)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local6 = ((int) callResult_0[0]); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) - memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, local8) != 0) { + break label_6; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg4); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local5); + callArgs_1[2] = ((long) 30023); + callArgs_1[1] = ((long) local6); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + arg4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_5; + } + break label_2; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_4; + } + } + label_7: { + arg1 = (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24) * 12)); + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, arg2) != 0) { + break label_7; + } + arg4 = 0; + break label_2; + } + arg2 = (arg2 - local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg2, -1) != 0) { + break label_3; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg4 = ((int) callResult_4[0]); + arg2 = arg4; + label_8: { + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local6) != 0) { + break label_8; + } + arg2 = arg4; + label_9: while (true) { + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + arg2 = (arg2 + 8); + local6 = (local6 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) arg4); + callArgs_5[0] = ((long) arg3); + instance.getMachine().call(344, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg4); + instance.getMachine().call(1777, callArgs_6); + } + arg4 = 0; + break label_1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 0); + callArgs_8[1] = ((long) 0); + callArgs_8[0] = ((long) arg3); + instance.getMachine().call(344, callArgs_8); + } + instance.global(0).setValue(((long) (local5 + 64))); + return arg4; + } + + public static long[] call_358(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_358(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_359(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 224); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 224, (int) (local4 + 1)); + label_1: { + label_2: { + if (local4 != 0) { + break label_2; + } + local4 = 0; + break label_1; + } + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 18552); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(337, callArgs_0); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])); + } + local5 = (local3 + 56); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeLong((int) (local3 + 48) < 0 ? (local3 + 48) : (local3 + 48) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) 0L); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) local3); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + arg2 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 72)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local6 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 12348); + callArgs_3[3] = ((long) (local3 + 40)); + callArgs_3[2] = ((long) (arg0 + 152)); + callArgs_3[1] = ((long) local6); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(356, callArgs_3); + local7 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg2); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + arg2 = (local4 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7)); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local3 < 0 ? local3 : local3 + 40), memory.readInt((int) local3 < 0 ? local3 : local3 + 44)) != 0) { + break label_3; + } + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) 0); + callArgs_6[2] = ((long) 1217); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + arg2 = (arg2 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_6[0]))); + } + label_4: { + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local3 < 0 ? local3 : local3 + 52), local4) != 0) { + break label_4; + } + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) 0); + callArgs_7[2] = ((long) 14432); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + arg2 = (arg2 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_7[0]))); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 52); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_5; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) local4); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_8); + } + label_6: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_6; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 44, (int) arg0); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_9); + } + instance.global(0).setValue(((long) (local3 + 112))); + return arg2; + } + + public static long[] call_359(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_359(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_360(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_2; + } + local5 = 0; + local6 = -4294967296L; + break label_1; + } + label_3: { + label_4: { + label_5: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (local4 + 24)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local7 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local7); + callArgs_1[0] = ((long) (local4 + 64)); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + arg2 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local4 + 104)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local8 = ((int) callResult_2[0]); + local5 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local9 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local9) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local5); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 17326); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local4); + callArgs_3[2] = ((long) 30023); + callArgs_3[1] = ((long) local8); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(337, callArgs_3); + local5 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local8); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_4; + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5); + local6 = -4294967296L; + break label_3; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local8); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + } + local6 = memory.readLong((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) << 5)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) << 5)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) << 5)) + 0); + local5 = 0; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg2); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local7); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3); + label_6: { + label_7: { + label_8: { + label_9: { + arg3 = memory.readInt((int) (arg0 + 216) < 0 ? (arg0 + 216) : (arg0 + 216) + 0); + arg2 = memory.readInt((int) (arg0 + 220) < 0 ? (arg0 + 220) : (arg0 + 220) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, arg2) != 0) { + break label_9; + } + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 12, (long) local6); + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 8, (byte) (local7)); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) -64L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 216, (int) (arg3 + 20)); + break label_8; + } + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 212); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg3 - local8), 20); + local9 = (local10 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 214748365) != 0) { + break label_7; + } + label_10: { + label_11: { + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg2 - local8), 20); + local11 = (arg2 << 1); + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 107374182) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local11, local9) != 0 ? local11 : local9) : 214748364); + if (local9 != 0) { + break label_11; + } + local11 = 0; + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, 214748365) != 0) { + break label_6; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) (local9 * 20)); + long[] callResult_8 = instance.getMachine().call(1776, callArgs_8); + local11 = ((int) callResult_8[0]); + } + arg2 = (local11 + (local10 * 20)); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 12, (long) local6); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 8, (byte) (local7)); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) -64L); + local7 = (local11 + (local9 * 20)); + local9 = (arg2 + 20); + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, arg3) != 0) { + break label_12; + } + label_13: while (true) { + arg2 = (arg2 + -20); + arg3 = (arg3 + -20); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) memory.readInt((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0)); + memory.writeLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (long) memory.readLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, arg3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break; + } + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 212); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 220, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 216, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 212, (int) arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_8; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg3); + instance.getMachine().call(1777, callArgs_9); + } + instance.global(0).setValue(((long) (local4 + 144))); + return local5; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_360(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_360(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_361(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + long local6 = 0L; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = memory.readInt((int) (arg0 + 216) < 0 ? (arg0 + 216) : (arg0 + 216) + 0); + if (((int) memory.read((int) (local4 + -12) < 0 ? (local4 + -12) : (local4 + -12) + 0) & 0xFF) != 0) { + break label_2; + } + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + arg0 = 0; + break label_1; + } + local6 = memory.readLong((int) (local4 + -8) < 0 ? (local4 + -8) : (local4 + -8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local6); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) local5); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local6); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) local5); + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 7014); + callArgs_0[3] = ((long) local3); + callArgs_0[2] = ((long) (local3 + 8)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(349, callArgs_0); + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])); + } + memory.writeLong((int) (local4 + -20) < 0 ? (local4 + -20) : (local4 + -20) + 0, (long) local5); + instance.global(0).setValue(((long) (local3 + 32))); + return arg0; + } + + public static long[] call_361(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_361(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_362(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 232, (int) arg1); + return; + } + + public static long[] call_362(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_362(arg0, arg1, memory, instance); + return null; + } + + public static int func_363(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + local5 = 0; + label_1: { + if (arg3 != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (local4 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 0); + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(355, callArgs_1); + arg3 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3); + } + instance.global(0).setValue(((long) (local4 + 48))); + return local5; + } + + public static long[] call_363(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_363(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_364(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local1 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 272); + local3 = memory.readInt((int) (arg0 + 276) < 0 ? (arg0 + 276) : (arg0 + 276) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_2; + } + local4 = 0; + break label_1; + } + local4 = 0; + label_3: while (true) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) (local1 + 56)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) (local1 + 16)); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + local6 = ((int) callResult_1[0]); + local7 = memory.readInt((int) local1 < 0 ? local1 : local1 + 40); + label_4: { + label_5: { + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 264); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_5; + } + label_6: while (true) { + label_7: { + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, local9) != 0) { + break label_7; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, local7) != 0) { + break label_8; + } + local8 = 0; + break label_4; + } + local8 = (local8 + 4); + } + local8 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + if (local8 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) local7); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local1); + callArgs_2[2] = ((long) 7981); + callArgs_2[1] = ((long) local6); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(337, callArgs_2); + local8 = ((int) callResult_2[0]); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local8)); + local2 = (local2 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + instance.global(0).setValue(((long) (local1 + 96))); + return local4; + } + + public static long[] call_364(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_364(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_365(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local3 + 24)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) (local3 + 88)); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + arg1 = ((int) callResult_1[0]); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 216) < 0 ? (arg0 + 216) : (arg0 + 216) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 212)), 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local6) != 0) { + break label_5; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 6913); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) 30023); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(337, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + if (local5 != 0) { + break label_4; + } + break label_3; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + if (arg2 != 0) { + break label_3; + } + local5 = 0; + break label_1; + } + memory.writeI32((int) (local3 + 80) < 0 ? (local3 + 80) : (local3 + 80) + 0, (int) 0); + memory.writeLong((int) (local3 + 72) < 0 ? (local3 + 72) : (local3 + 72) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) 0L); + break label_2; + } + arg0 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 212) + (memory.readInt((int) local4 < 0 ? local4 : local4 + 24) * 20)); + memory.writeLong((int) ((local3 + 64) + 8) < 0 ? ((local3 + 64) + 8) : ((local3 + 64) + 8) + 0, (long) memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0)); + memory.writeI32((int) ((local3 + 64) + 16) < 0 ? ((local3 + 64) + 16) : ((local3 + 64) + 16) + 0, (int) memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + local5 = 0; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 64)); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) memory.readInt((int) ((local3 + 64) + 16) < 0 ? ((local3 + 64) + 16) : ((local3 + 64) + 16) + 0)); + memory.writeLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (long) memory.readLong((int) ((local3 + 64) + 8) < 0 ? ((local3 + 64) + 8) : ((local3 + 64) + 8) + 0)); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 128))); + return local5; + } + + public static long[] call_365(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_365(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_366(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + local6 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 88, (int) arg2); + label_1: { + label_2: { + arg2 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg2, 0) != 0) { + break label_2; + } + memory.writeLong((int) (local6 + 72) < 0 ? (local6 + 72) : (local6 + 72) + 0, (long) 0L); + memory.writeLong((int) (local6 + 64) < 0 ? (local6 + 64) : (local6 + 64) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 56, (long) 0L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (local6 + 16)); + long[] callResult_0 = instance.getMachine().call(155, callArgs_0); + arg3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local6 + 56)); + callArgs_1[1] = ((long) arg3); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(342, callArgs_1); + arg2 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg3); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local6 < 0 ? local6 : local6 + 60), memory.readInt((int) local6 < 0 ? local6 : local6 + 56)) != 0) { + break label_3; + } + if ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 7) & 0xFF) & 255) != 0) { + break label_3; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local6 + 88)); + callArgs_3[0] = ((long) (local6 + 96)); + instance.getMachine().call(192, callArgs_3); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 96)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local6); + callArgs_4[2] = ((long) 29097); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(337, callArgs_4); + arg3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0]))); + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg4, (local6 + 56)) != 0) { + break label_4; + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 60)); + callArgs_5[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 56)); + callArgs_5[0] = ((long) arg4); + instance.getMachine().call(344, callArgs_5); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg5, (local6 + 68)) != 0) { + break label_5; + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) memory.readInt((int) (local6 + 72) < 0 ? (local6 + 72) : (local6 + 72) + 0)); + callArgs_6[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 68)); + callArgs_6[0] = ((long) arg5); + instance.getMachine().call(344, callArgs_6); + } + label_6: { + arg5 = memory.readInt((int) local6 < 0 ? local6 : local6 + 68); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg5) != 0) { + break label_6; + } + memory.writeI32((int) (local6 + 72) < 0 ? (local6 + 72) : (local6 + 72) + 0, (int) arg5); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg5); + instance.getMachine().call(1777, callArgs_7); + } + arg5 = memory.readInt((int) local6 < 0 ? local6 : local6 + 56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg5) != 0) { + break label_1; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 60, (int) arg5); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg5); + instance.getMachine().call(1777, callArgs_8); + break label_1; + } + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 4, (int) memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0)); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) arg3); + callArgs_9[0] = ((long) (local6 + 96)); + instance.getMachine().call(367, callArgs_9); + label_7: { + arg4 = memory.readInt((int) arg5 < 0 ? arg5 : arg5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_7; + } + memory.writeI32((int) arg5 < 0 ? arg5 : arg5 + 4, (int) arg4); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg4); + instance.getMachine().call(1777, callArgs_10); + } + memory.writeI32((int) arg5 < 0 ? arg5 : arg5 + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 96)); + memory.writeLong((int) arg5 < 0 ? arg5 : arg5 + 4, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 100)); + arg3 = 0; + } + instance.global(0).setValue(((long) (local6 + 160))); + return arg3; + } + + public static long[] call_366(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int result = Wat2WasmMachine.func_366(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_367(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + label_1: { + label_2: { + label_3: { + switch((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 64)) { + case 0: + { + break label_1; + } + case 1: + { + break label_2; + } + case 2: + { + break label_2; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_2; + } + case 6: + { + break label_2; + } + case 7: + { + break label_2; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_2; + } + case 19: + { + break label_2; + } + case 20: + { + break label_2; + } + case 21: + { + break label_2; + } + case 22: + { + break label_2; + } + case 23: + { + break label_2; + } + case 24: + { + break label_2; + } + case 25: + { + break label_2; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_2; + } + case 29: + { + break label_2; + } + case 30: + { + break label_2; + } + case 31: + { + break label_2; + } + case 32: + { + break label_2; + } + case 33: + { + break label_2; + } + case 34: + { + break label_2; + } + case 35: + { + break label_2; + } + case 36: + { + break label_2; + } + case 37: + { + break label_2; + } + case 38: + { + break label_2; + } + case 39: + { + break label_2; + } + case 40: + { + break label_2; + } + case 41: + { + break label_3; + } + case 42: + { + break label_2; + } + case 43: + { + break label_3; + } + case 44: + { + break label_2; + } + case 45: + { + break label_2; + } + case 46: + { + break label_2; + } + case 47: + { + break label_3; + } + case 48: + { + break label_3; + } + case 49: + { + break label_2; + } + case 50: + { + break label_2; + } + case 51: + { + break label_2; + } + case 52: + { + break label_2; + } + case 53: + { + break label_2; + } + case 54: + { + break label_2; + } + case 55: + { + break label_2; + } + case 56: + { + break label_2; + } + case 57: + { + break label_2; + } + case 58: + { + break label_2; + } + case 59: + { + break label_3; + } + case 60: + { + break label_3; + } + case 61: + { + break label_3; + } + case 62: + { + break label_3; + } + case 63: + { + break label_3; + } + default: + { + break label_2; + } + } + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 8); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + local3 = (local2 + 8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + return; + } + + public static long[] call_367(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_367(arg0, arg1, memory, instance); + return null; + } + + public static int func_368(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 108, (byte) (1)); + local4 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) local4); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (arg0 + 24)); + long[] callResult_0 = instance.getMachine().call(333, callArgs_0); + arg0 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return arg0; + } + + public static long[] call_368(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_368(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_369(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 108, (byte) (0)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 24)); + long[] callResult_0 = instance.getMachine().call(334, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_369(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_369(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_370(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 240) < 0 ? (arg0 + 240) : (arg0 + 240) + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 236)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 156) < 0 ? (arg0 + 156) : (arg0 + 156) + 0) - arg1), 28), arg2) != 0) { + break label_6; + } + local4 = (arg1 + (arg2 * 28)); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local5) != 0) { + break label_2; + } + label_7: while (true) { + label_8: { + label_9: { + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 236); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 240); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_9; + } + local4 = 0; + break label_8; + } + local4 = memory.readInt((int) (arg1 + -4) < 0 ? (arg1 + -4) : (arg1 + -4) + 0); + } + local9 = memory.readLong((int) local5 < 0 ? local5 : local5 + 0); + local10 = (local4 + 1); + label_10: { + label_11: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 244); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local4) != 0) { + break label_11; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local10); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 240, (int) (arg1 + 12)); + break label_10; + } + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local7), 12); + local12 = (local11 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local12, 357913942) != 0) { + break label_5; + } + label_12: { + label_13: { + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local7), 12); + local13 = (local4 << 1); + local12 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local13, local12) != 0 ? local13 : local12) : 357913941); + if (local12 != 0) { + break label_13; + } + local13 = 0; + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local12, 357913942) != 0) { + break label_4; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local12 * 12)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local13 = ((int) callResult_0[0]); + } + local4 = (local13 + (local11 * 12)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local10); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) local9); + local10 = (local13 + (local12 * 12)); + local12 = (local4 + 12); + label_14: { + if (local8 != 0) { + break label_14; + } + label_15: while (true) { + local4 = (local4 + -12); + arg1 = (arg1 + -12); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_15; + } + break; + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 236); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 244, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 240, (int) local12); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 236, (int) local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_10; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_1); + } + local5 = (local5 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local5) != 0) { + break label_3; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(261, callArgs_2); + arg1 = ((int) callResult_2[0]); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local4); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + break label_1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 152); + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) ((arg1 + (arg2 * 28)) + 12)); + callArgs_6[0] = ((long) (arg0 + 24)); + long[] callResult_6 = instance.getMachine().call(261, callArgs_6); + arg1 = ((int) callResult_6[0]); + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg1; + } + + public static long[] call_370(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_370(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_371(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 24)); + long[] callResult_0 = instance.getMachine().call(332, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_371(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_371(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_372(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + int local9 = 0; + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 236); + local5 = memory.readInt((int) (arg0 + 240) < 0 ? (arg0 + 240) : (arg0 + 240) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + local7 = 0; + break label_1; + } + local7 = memory.readInt((int) (local5 + -4) < 0 ? (local5 + -4) : (local5 + -4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U((local7 ^ -1), arg2) != 0) { + break label_1; + } + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 28503); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(337, callArgs_0); + return 1; + } + local7 = (local7 + arg2); + local8 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + label_3: { + arg2 = memory.readInt((int) (arg0 + 244) < 0 ? (arg0 + 244) : (arg0 + 244) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, arg2) != 0) { + break label_3; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local7); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 240, (int) (local5 + 12)); + return 0; + } + label_4: { + label_5: { + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local4), 12); + arg3 = (local9 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, 357913942) != 0) { + break label_5; + } + label_6: { + label_7: { + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg2 - local4), 12); + arg1 = (arg2 << 1); + arg3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, arg3) != 0 ? arg1 : arg3) : 357913941); + if (arg3 != 0) { + break label_7; + } + arg1 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, 357913942) != 0) { + break label_4; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg3 * 12)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg1 = ((int) callResult_1[0]); + } + arg2 = (arg1 + (local9 * 12)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) local7); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) local8); + arg3 = (arg1 + (arg3 * 12)); + local7 = (arg2 + 12); + label_8: { + if (local6 != 0) { + break label_8; + } + label_9: while (true) { + arg2 = (arg2 + -12); + local5 = (local5 + -12); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (int) memory.readInt((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 236); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 244, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 240, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 236, (int) arg2); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_10; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_2); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_372(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_372(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_373(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) 478); + label_1: { + label_2: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (local4 != 0) { + break label_2; + } + local5 = 0; + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 24)); + callArgs_0[0] = ((long) (local3 + 32)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local5 = 1; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) 5674); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(337, callArgs_2); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0]))); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) (arg0 + 24)); + long[] callResult_3 = instance.getMachine().call(267, callArgs_3); + arg0 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 96))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_373(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_373(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_374(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg2); + local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local8 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 30) != 0) { + break label_2; + } + local7 = 0; + if (((1 << local8) & 2013265921) != 0) { + break label_1; + } + } + local7 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local7 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 + 80)); + callArgs_0[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local6 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local7 = 1; + } + memory.writeI32((int) (local6 + 95) < 0 ? (local6 + 95) : (local6 + 95) + 0, (int) 0); + memory.writeLong((int) ((local6 + 80) + 8) < 0 ? ((local6 + 80) + 8) : ((local6 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local6 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 104)); + callArgs_5[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local6 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQ(arg4, local9) != 0) { + break label_5; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local6); + callArgs_7[2] = ((long) 29689); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(262, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local6 + 176))); + return ((((local7 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_374(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_374(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_375(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg2); + local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local8 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 30) != 0) { + break label_2; + } + local7 = 0; + if (((1 << local8) & 2013265921) != 0) { + break label_1; + } + } + local7 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local7 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 + 80)); + callArgs_0[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local6 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local7 = 1; + } + memory.writeI32((int) (local6 + 95) < 0 ? (local6 + 95) : (local6 + 95) + 0, (int) 0); + memory.writeLong((int) ((local6 + 80) + 8) < 0 ? ((local6 + 80) + 8) : ((local6 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local6 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 104)); + callArgs_5[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local6 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQ(arg4, local9) != 0) { + break label_5; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local6); + callArgs_7[2] = ((long) 29689); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(268, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local6 + 176))); + return ((((local7 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_375(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_375(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_376(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg2); + local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local8 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 30) != 0) { + break label_2; + } + local7 = 0; + if (((1 << local8) & 2013265921) != 0) { + break label_1; + } + } + local7 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local7 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 + 80)); + callArgs_0[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local6 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local7 = 1; + } + memory.writeI32((int) (local6 + 95) < 0 ? (local6 + 95) : (local6 + 95) + 0, (int) 0); + memory.writeLong((int) ((local6 + 80) + 8) < 0 ? ((local6 + 80) + 8) : ((local6 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local6 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 104)); + callArgs_5[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local6 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQ(arg4, local9) != 0) { + break label_5; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local6); + callArgs_7[2] = ((long) 29689); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(265, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local6 + 176))); + return ((((local7 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_376(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_376(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_377(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg2); + local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local8 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 30) != 0) { + break label_2; + } + local7 = 0; + if (((1 << local8) & 2013265921) != 0) { + break label_1; + } + } + local7 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local7 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 + 80)); + callArgs_0[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local6 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local7 = 1; + } + memory.writeI32((int) (local6 + 95) < 0 ? (local6 + 95) : (local6 + 95) + 0, (int) 0); + memory.writeLong((int) ((local6 + 80) + 8) < 0 ? ((local6 + 80) + 8) : ((local6 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local6 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 104)); + callArgs_5[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local6 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQ(arg4, local9) != 0) { + break label_5; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local6); + callArgs_7[2] = ((long) 29689); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(264, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local6 + 176))); + return ((((local7 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_377(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_377(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_378(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg2); + local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local8 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 30) != 0) { + break label_2; + } + local7 = 0; + if (((1 << local8) & 2013265921) != 0) { + break label_1; + } + } + local7 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local7 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 + 80)); + callArgs_0[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local6 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local7 = 1; + } + memory.writeI32((int) (local6 + 95) < 0 ? (local6 + 95) : (local6 + 95) + 0, (int) 0); + memory.writeLong((int) ((local6 + 80) + 8) < 0 ? ((local6 + 80) + 8) : ((local6 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local6 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 104)); + callArgs_5[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local6 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQ(arg4, local9) != 0) { + break label_5; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local6); + callArgs_7[2] = ((long) 29689); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(263, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local6 + 176))); + return ((((local7 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_378(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_378(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_379(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg2); + local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local8 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 30) != 0) { + break label_2; + } + local7 = 0; + if (((1 << local8) & 2013265921) != 0) { + break label_1; + } + } + local7 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local7 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 + 80)); + callArgs_0[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local6 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local7 = 1; + } + memory.writeI32((int) (local6 + 95) < 0 ? (local6 + 95) : (local6 + 95) + 0, (int) 0); + memory.writeLong((int) ((local6 + 80) + 8) < 0 ? ((local6 + 80) + 8) : ((local6 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local6 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 104)); + callArgs_5[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local6 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQ(arg4, local9) != 0) { + break label_5; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local6); + callArgs_7[2] = ((long) 29689); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(266, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local6 + 176))); + return ((((local7 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_379(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_379(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_380(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg2); + local4 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local5 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 30) != 0) { + break label_2; + } + if (((1 << local5) & 2013265921) != 0) { + break label_1; + } + } + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + local5 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 21) != 0) { + break label_4; + } + if (((1835015 >>> local5) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) (local3 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local4 = 1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(269, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local3 + 80))); + return (local4 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_380(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_380(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_381(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 2); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 32)); + callArgs_0[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) 0L); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local5); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = ((long) (local3 + 32)); + callArgs_2[4] = ((long) (local3 + 48)); + callArgs_2[3] = ((long) (local3 + 8)); + callArgs_2[2] = ((long) 2); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(366, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 32)); + callArgs_3[1] = ((long) (local3 + 48)); + callArgs_3[0] = ((long) (arg0 + 24)); + long[] callResult_3 = instance.getMachine().call(270, callArgs_3); + arg2 = ((int) callResult_3[0]); + label_2: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + } + label_3: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) arg0); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local3 + 112))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)); + } + + public static long[] call_381(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_381(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_382(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) 12); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) (local3 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(271, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local3 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_382(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_382(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_383(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) 13); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) (local3 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(272, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local3 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_383(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_383(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_384(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 14); + label_1: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(273, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_384(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_384(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_385(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + callArgs_0[0] = ((long) (arg0 + 24)); + long[] callResult_0 = instance.getMachine().call(274, callArgs_0); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])); + } + + public static long[] call_385(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_385(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_386(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 14); + label_1: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(275, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_386(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_386(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_387(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) 16); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 48)); + callArgs_0[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 80)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeLong((int) ((local3 + 48) + 16) < 0 ? ((local3 + 48) + 16) : ((local3 + 48) + 16) + 0, (long) 0L); + memory.writeLong((int) ((local3 + 48) + 8) < 0 ? ((local3 + 48) + 8) : ((local3 + 48) + 8) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 8)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) (local3 + 80)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) 12348); + callArgs_4[3] = ((long) (local3 + 48)); + callArgs_4[2] = ((long) (arg0 + 152)); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(356, callArgs_4); + local5 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg2); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local3 + 60)); + callArgs_7[1] = ((long) (local3 + 48)); + callArgs_7[0] = ((long) (arg0 + 24)); + long[] callResult_7 = instance.getMachine().call(276, callArgs_7); + arg1 = ((int) callResult_7[0]); + label_2: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) (local3 + 64) < 0 ? (local3 + 64) : (local3 + 64) + 0, (int) arg0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_8); + } + label_3: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) arg0); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_9); + } + instance.global(0).setValue(((long) (local3 + 144))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)); + } + + public static long[] call_387(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_387(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_388(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local4 = (((int) instance.global(0).getValue()) - 304); + instance.global(0).setValue(((long) local4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 232, (int) 17); + label_1: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 232)); + callArgs_0[0] = ((long) (local4 + 168)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 168)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local4 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeLong((int) ((local4 + 136) + 16) < 0 ? ((local4 + 136) + 16) : ((local4 + 136) + 16) + 0, (long) 0L); + memory.writeLong((int) ((local4 + 136) + 8) < 0 ? ((local4 + 136) + 8) : ((local4 + 136) + 8) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 136, (long) 0L); + memory.writeLong((int) ((local4 + 104) + 16) < 0 ? ((local4 + 104) + 16) : ((local4 + 104) + 16) + 0, (long) 0L); + memory.writeI32((int) (local4 + 127) < 0 ? (local4 + 127) : (local4 + 127) + 0, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 112, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) -4294967296L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local4 + 64)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local4 + 136)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(342, callArgs_3); + local6 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6)); + arg2 = ((local4 + 104) + 8); + label_2: { + label_3: { + label_4: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg3); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local7 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local7); + callArgs_6[0] = ((long) (local4 + 232)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local5 = ((int) callResult_6[0]); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local5); + callArgs_7[0] = ((long) (local4 + 168)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + arg3 = ((int) callResult_7[0]); + local8 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 24); + local9 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, local9) != 0) { + break label_4; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 17326); + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) local4); + callArgs_8[2] = ((long) 30023); + callArgs_8[1] = ((long) arg3); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + local8 = ((int) callResult_8[0]); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg3); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_3; + } + arg3 = 0; + memory.writeByte((int) (local4 + 276) < 0 ? (local4 + 276) : (local4 + 276) + 0, (byte) (0)); + memory.writeLong((int) (local4 + 288) < 0 ? (local4 + 288) : (local4 + 288) + 0, (long) 0L); + memory.writeI32((int) (local4 + 295) < 0 ? (local4 + 295) : (local4 + 295) + 0, (int) 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 272, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 280, (long) 0L); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local8); + local9 = -1; + break label_2; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg3); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + } + arg3 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) local5 < 0 ? local5 : local5 + 24) << 5)); + memory.writeLong((int) (local4 + 288) < 0 ? (local4 + 288) : (local4 + 288) + 0, (long) memory.readLong((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0)); + memory.writeI32((int) (local4 + 295) < 0 ? (local4 + 295) : (local4 + 295) + 0, (int) memory.readInt((int) (arg3 + 23) < 0 ? (arg3 + 23) : (arg3 + 23) + 0)); + memory.writeByte((int) (local4 + 276) < 0 ? (local4 + 276) : (local4 + 276) + 0, (byte) (((int) memory.read((int) (arg3 + 31) < 0 ? (arg3 + 31) : (arg3 + 31) + 0) & 0xFF))); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 280, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 8)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 272, (int) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 27)); + local9 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + arg3 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + local8 = 0; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 280)); + memory.writeLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (long) memory.readLong((int) ((local4 + 280) + 8) < 0 ? ((local4 + 280) + 8) : ((local4 + 280) + 8) + 0)); + memory.writeI32((int) (arg2 + 15) < 0 ? (arg2 + 15) : (arg2 + 15) + 0, (int) memory.readInt((int) ((local4 + 280) + 15) < 0 ? ((local4 + 280) + 15) : ((local4 + 280) + 15) + 0)); + memory.writeByte((int) (local4 + 135) < 0 ? (local4 + 135) : (local4 + 135) + 0, (byte) (((int) memory.read((int) (local4 + 276) < 0 ? (local4 + 276) : (local4 + 276) + 0) & 0xFF))); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 108, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 131, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 272)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 104, (int) arg3); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local5); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local7); + long[] callResult_12 = instance.getMachine().call(162, callArgs_12); + local5 = (local6 | local8); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-16, arg3) != 0) { + break label_5; + } + long[] callArgs_13 = new long[4]; + callArgs_13[3] = ((long) 0); + callArgs_13[2] = ((long) 16061); + callArgs_13[1] = ((long) arg1); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(337, callArgs_13); + local5 = (local5 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_13[0]))); + } + long[] callArgs_14 = new long[4]; + callArgs_14[3] = ((long) arg2); + callArgs_14[2] = ((long) (local4 + 148)); + callArgs_14[1] = ((long) (local4 + 136)); + callArgs_14[0] = ((long) (arg0 + 24)); + long[] callResult_14 = instance.getMachine().call(277, callArgs_14); + arg1 = ((int) callResult_14[0]); + label_6: { + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 148); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_6; + } + memory.writeI32((int) (local4 + 152) < 0 ? (local4 + 152) : (local4 + 152) + 0, (int) arg0); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_15); + } + label_7: { + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 136); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_7; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 140, (int) arg0); + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_16); + } + instance.global(0).setValue(((long) (local4 + 304))); + return (local5 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)); + } + + public static long[] call_388(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_388(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_389(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 20); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 56)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 56)); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(278, callArgs_2); + local4 = 1; + break label_1; + } + local4 = 1; + local5 = (arg0 + 24); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 56)); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = instance.getMachine().call(278, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_1; + } + memory.writeLong((int) (local3 + 80) < 0 ? (local3 + 80) : (local3 + 80) + 0, (long) 0L); + memory.writeLong((int) (local3 + 72) < 0 ? (local3 + 72) : (local3 + 72) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) 0L); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg1); + callArgs_4[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 56)); + callArgs_4[0] = ((long) (local3 + 16)); + long[] callResult_4 = instance.getMachine().call(155, callArgs_4); + arg1 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local3 + 64)); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(342, callArgs_5); + arg0 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + label_3: { + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local3 + 76)); + callArgs_7[1] = ((long) (local3 + 64)); + callArgs_7[0] = ((long) local5); + long[] callResult_7 = instance.getMachine().call(276, callArgs_7); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_7[0]))); + if (local4 != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 56)); + } + label_4: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_4; + } + memory.writeI32((int) (local3 + 80) < 0 ? (local3 + 80) : (local3 + 80) + 0, (int) arg0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_8); + } + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 68, (int) arg0); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_9); + } + instance.global(0).setValue(((long) (local3 + 128))); + return local4; + } + + public static long[] call_389(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_389(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_390(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 48, (int) 7); + label_1: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 48)); + callArgs_0[0] = ((long) (local4 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 64)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local4); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_3; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 64, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 72, (int) 0); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 64)); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(282, callArgs_2); + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])); + label_4: { + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_4; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 68, (int) arg0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_3); + } + arg0 = (arg1 | arg3); + break label_2; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 48, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 56, (int) 0); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local4 + 8)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg1 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) (local4 + 64)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + arg3 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[5]; + callArgs_6[4] = ((long) 14710); + callArgs_6[3] = ((long) (local4 + 48)); + callArgs_6[2] = ((long) (arg0 + 200)); + callArgs_6[1] = ((long) arg3); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(358, callArgs_6); + arg2 = ((int) callResult_6[0]); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg3); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) (local4 + 48)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(282, callArgs_9); + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_9[0])); + label_5: { + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 52, (int) arg0); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_10); + } + arg0 = (arg1 | arg3); + } + instance.global(0).setValue(((long) (local4 + 128))); + return arg0; + } + + public static long[] call_390(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_390(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_391(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg2); + local4 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local5 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 30) != 0) { + break label_2; + } + if (((1 << local5) & 2013265921) != 0) { + break label_1; + } + } + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + local5 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 21) != 0) { + break label_4; + } + if (((1835015 >>> local5) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) (local3 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local4 = 1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(281, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local3 + 80))); + return (local4 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_391(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_391(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_392(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + local4 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) local4); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (arg0 + 24)); + long[] callResult_0 = instance.getMachine().call(283, callArgs_0); + arg0 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0); + } + + public static long[] call_392(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_392(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_393(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg2); + local4 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local5 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 30) != 0) { + break label_2; + } + if (((1 << local5) & 2013265921) != 0) { + break label_1; + } + } + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + local5 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 21) != 0) { + break label_4; + } + if (((1835015 >>> local5) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) (local3 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local4 = 1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(284, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local3 + 80))); + return (local4 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_393(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_393(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_394(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 72, (int) 205); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 72)); + callArgs_0[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 80)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + arg1 = 0; + label_2: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 32)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local3 + 80)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local6 = ((int) callResult_3[0]); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 232); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, local8) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 6926); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local3); + callArgs_4[2] = ((long) 30023); + callArgs_4[1] = ((long) local6); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(337, callArgs_4); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local5); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + callArgs_7[0] = ((long) (arg0 + 24)); + long[] callResult_7 = instance.getMachine().call(299, callArgs_7); + arg0 = ((int) callResult_7[0]); + instance.global(0).setValue(((long) (local3 + 144))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | arg1) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_394(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_394(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_395(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) 21); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) (local3 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(285, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local3 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_395(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_395(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_396(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 23); + label_1: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(286, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_396(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_396(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_397(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 209); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 56)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 16)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(365, callArgs_3); + local5 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + callArgs_5[0] = ((long) (arg0 + 24)); + long[] callResult_5 = instance.getMachine().call(305, callArgs_5); + arg0 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local3 + 128))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_397(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_397(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_398(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 24)); + long[] callResult_0 = instance.getMachine().call(287, callArgs_0); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])); + } + + public static long[] call_398(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_398(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_399(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 11); + label_1: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(289, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_399(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_399(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_400(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) -4294967296L); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 72, (byte) (1)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (local3 + 24)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 64)); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(357, callArgs_1); + local5 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + local6 = memory.readLong((int) local3 < 0 ? local3 : local3 + 64); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) local6); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local6); + label_1: { + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 8)); + callArgs_3[0] = ((long) (arg0 + 24)); + long[] callResult_3 = instance.getMachine().call(291, callArgs_3); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0]))); + if (local4 != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF) & 255)) != 0) { + break label_1; + } + local4 = 0; + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 228)) != 0) { + break label_2; + } + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) 0); + callArgs_4[2] = ((long) 13707); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(337, callArgs_4); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 72) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) 0); + callArgs_5[2] = ((long) 13650); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0]))); + } + instance.global(0).setValue(((long) (local3 + 80))); + return local4; + } + + public static long[] call_400(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_400(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_401(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local3 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) 31); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 88)); + callArgs_0[0] = ((long) (local3 + 96)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 96)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 96, (long) -4294967296L); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 104, (byte) (1)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 48)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 96)); + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(357, callArgs_3); + local6 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6)); + label_2: { + if (((int) memory.read((int) local3 < 0 ? local3 : local3 + 104) & 0xFF) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local3 + 16)); + callArgs_5[2] = ((long) 28765); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local4 = (local4 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0]))); + } + local7 = memory.readLong((int) local3 < 0 ? local3 : local3 + 96); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local7); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local7); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local3 + 8)); + callArgs_6[0] = ((long) (arg0 + 24)); + long[] callResult_6 = instance.getMachine().call(292, callArgs_6); + arg0 = ((int) callResult_6[0]); + instance.global(0).setValue(((long) (local3 + 160))); + return (local4 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_401(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_401(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_402(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 4); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 32)); + callArgs_0[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) 0L); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local5); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = ((long) (local3 + 32)); + callArgs_2[4] = ((long) (local3 + 48)); + callArgs_2[3] = ((long) (local3 + 8)); + callArgs_2[2] = ((long) 4); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(366, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 32)); + callArgs_3[1] = ((long) (local3 + 48)); + callArgs_3[0] = ((long) (arg0 + 24)); + long[] callResult_3 = instance.getMachine().call(290, callArgs_3); + arg2 = ((int) callResult_3[0]); + label_2: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + } + label_3: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) arg0); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local3 + 112))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)); + } + + public static long[] call_402(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_402(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_403(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg2); + local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local8 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 30) != 0) { + break label_2; + } + local7 = 0; + if (((1 << local8) & 2013265921) != 0) { + break label_1; + } + } + local7 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local7 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 + 80)); + callArgs_0[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local6 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local7 = 1; + } + memory.writeI32((int) (local6 + 95) < 0 ? (local6 + 95) : (local6 + 95) + 0, (int) 0); + memory.writeLong((int) ((local6 + 80) + 8) < 0 ? ((local6 + 80) + 8) : ((local6 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local6 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 104)); + callArgs_5[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local6 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(local9, arg4) != 0) { + break label_5; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local6); + callArgs_7[2] = ((long) 29741); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(293, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local6 + 176))); + return ((((local7 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_403(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_403(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_404(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg2); + local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local8 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 30) != 0) { + break label_2; + } + local7 = 0; + if (((1 << local8) & 2013265921) != 0) { + break label_1; + } + } + local7 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local7 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 + 80)); + callArgs_0[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local6 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local7 = 1; + } + memory.writeI32((int) (local6 + 95) < 0 ? (local6 + 95) : (local6 + 95) + 0, (int) 0); + memory.writeLong((int) ((local6 + 80) + 8) < 0 ? ((local6 + 80) + 8) : ((local6 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local6 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 104)); + callArgs_5[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local6 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(local9, arg4) != 0) { + break label_5; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local6); + callArgs_7[2] = ((long) 29741); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(293, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local6 + 176))); + return ((((local7 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_404(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_404(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_405(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg2); + local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local8 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 30) != 0) { + break label_2; + } + local7 = 0; + if (((1 << local8) & 2013265921) != 0) { + break label_1; + } + } + local7 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local7 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 + 80)); + callArgs_0[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local6 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local7 = 1; + } + memory.writeI32((int) (local6 + 95) < 0 ? (local6 + 95) : (local6 + 95) + 0, (int) 0); + memory.writeLong((int) ((local6 + 80) + 8) < 0 ? ((local6 + 80) + 8) : ((local6 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local6 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 104)); + callArgs_5[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local6 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(local9, arg4) != 0) { + break label_5; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local6); + callArgs_7[2] = ((long) 29741); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(293, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local6 + 176))); + return ((((local7 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_405(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_405(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_406(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + local3 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) 27); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 88)); + callArgs_0[0] = ((long) (local3 + 96)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 96)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + arg1 = 1; + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 48)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local4 = ((int) callResult_2[0]); + label_3: { + label_4: { + label_5: { + label_6: { + local5 = memory.readInt((int) (arg0 + 240) < 0 ? (arg0 + 240) : (arg0 + 240) + 0); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 236); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local5) != 0) { + break label_6; + } + arg1 = 0; + break label_5; + } + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - arg1), 12); + label_7: while (true) { + local7 = (arg2 >>> 1); + local8 = (arg1 + (local7 * 12)); + _snap_0 = local8; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(memory.readInt((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0), local6); + arg1 = (local8 != 0 ? arg1 : (_snap_0 + 12)); + arg2 = (local8 != 0 ? local7 : (arg2 + (local7 ^ -1))); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, arg1) != 0) { + break label_4; + } + arg1 = memory.readInt((int) (local5 + -4) < 0 ? (local5 + -4) : (local5 + -4) + 0); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg1); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) (local3 + 16)); + callArgs_3[2] = ((long) 30061); + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(337, callArgs_3); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])); + local9 = 0L; + local10 = -4294967296L; + break label_3; + } + local10 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + local9 = (local10 & 4294967295L); + local10 = (local10 & -4294967296L); + arg1 = 0; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local4); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local9 = (local9 | local10); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local9); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local9); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 8)); + callArgs_5[0] = ((long) (arg0 + 24)); + long[] callResult_5 = instance.getMachine().call(294, callArgs_5); + arg1 = (arg1 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0]))); + } + instance.global(0).setValue(((long) (local3 + 160))); + return arg1; + } + + public static long[] call_406(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_406(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_407(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + local3 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) 28); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 88)); + callArgs_0[0] = ((long) (local3 + 96)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 96)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + arg1 = 1; + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 48)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local4 = ((int) callResult_2[0]); + label_3: { + label_4: { + label_5: { + label_6: { + local5 = memory.readInt((int) (arg0 + 240) < 0 ? (arg0 + 240) : (arg0 + 240) + 0); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 236); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local5) != 0) { + break label_6; + } + arg1 = 0; + break label_5; + } + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - arg1), 12); + label_7: while (true) { + local7 = (arg2 >>> 1); + local8 = (arg1 + (local7 * 12)); + _snap_0 = local8; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(memory.readInt((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0), local6); + arg1 = (local8 != 0 ? arg1 : (_snap_0 + 12)); + arg2 = (local8 != 0 ? local7 : (arg2 + (local7 ^ -1))); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, arg1) != 0) { + break label_4; + } + arg1 = memory.readInt((int) (local5 + -4) < 0 ? (local5 + -4) : (local5 + -4) + 0); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg1); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) (local3 + 16)); + callArgs_3[2] = ((long) 30061); + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(337, callArgs_3); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])); + local9 = 0L; + local10 = -4294967296L; + break label_3; + } + local10 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + local9 = (local10 & 4294967295L); + local10 = (local10 & -4294967296L); + arg1 = 0; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local4); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local9 = (local9 | local10); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local9); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local9); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 8)); + callArgs_5[0] = ((long) (arg0 + 24)); + long[] callResult_5 = instance.getMachine().call(295, callArgs_5); + arg1 = (arg1 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0]))); + } + instance.global(0).setValue(((long) (local3 + 160))); + return arg1; + } + + public static long[] call_407(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_407(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_408(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + local3 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) 29); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 88)); + callArgs_0[0] = ((long) (local3 + 96)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 96)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + arg1 = 1; + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 48)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local4 = ((int) callResult_2[0]); + label_3: { + label_4: { + label_5: { + label_6: { + local5 = memory.readInt((int) (arg0 + 240) < 0 ? (arg0 + 240) : (arg0 + 240) + 0); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 236); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local5) != 0) { + break label_6; + } + arg1 = 0; + break label_5; + } + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - arg1), 12); + label_7: while (true) { + local7 = (arg2 >>> 1); + local8 = (arg1 + (local7 * 12)); + _snap_0 = local8; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(memory.readInt((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0), local6); + arg1 = (local8 != 0 ? arg1 : (_snap_0 + 12)); + arg2 = (local8 != 0 ? local7 : (arg2 + (local7 ^ -1))); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, arg1) != 0) { + break label_4; + } + arg1 = memory.readInt((int) (local5 + -4) < 0 ? (local5 + -4) : (local5 + -4) + 0); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg1); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) (local3 + 16)); + callArgs_3[2] = ((long) 30061); + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(337, callArgs_3); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])); + local9 = 0L; + local10 = -4294967296L; + break label_3; + } + local10 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + local9 = (local10 & 4294967295L); + local10 = (local10 & -4294967296L); + arg1 = 0; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local4); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local9 = (local9 | local10); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local9); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local9); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 8)); + callArgs_5[0] = ((long) (arg0 + 24)); + long[] callResult_5 = instance.getMachine().call(296, callArgs_5); + arg1 = (arg1 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0]))); + } + instance.global(0).setValue(((long) (local3 + 160))); + return arg1; + } + + public static long[] call_408(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_408(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_409(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 3); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 32)); + callArgs_0[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) 0L); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local5); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = ((long) (local3 + 32)); + callArgs_2[4] = ((long) (local3 + 48)); + callArgs_2[3] = ((long) (local3 + 8)); + callArgs_2[2] = ((long) 3); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(366, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 32)); + callArgs_3[1] = ((long) (local3 + 48)); + callArgs_3[0] = ((long) (arg0 + 24)); + long[] callResult_3 = instance.getMachine().call(297, callArgs_3); + arg2 = ((int) callResult_3[0]); + label_2: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + } + label_3: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) arg0); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local3 + 112))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)); + } + + public static long[] call_409(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_409(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_410(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 88, (int) 206); + label_1: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 88)); + callArgs_0[0] = ((long) (local4 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local4); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) ((local4 + 112) + 15) < 0 ? ((local4 + 112) + 15) : ((local4 + 112) + 15) + 0, (int) 0); + memory.writeLong((int) ((local4 + 112) + 8) < 0 ? ((local4 + 112) + 8) : ((local4 + 112) + 8) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 112, (long) 0L); + memory.writeI32((int) ((local4 + 88) + 15) < 0 ? ((local4 + 88) + 15) : ((local4 + 88) + 15) + 0, (int) 0); + memory.writeLong((int) ((local4 + 88) + 8) < 0 ? ((local4 + 88) + 8) : ((local4 + 88) + 8) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 88, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local4 + 48)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local4 + 88)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg3); + callArgs_5[0] = ((long) (local4 + 8)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + arg1 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) (local4 + 112)); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(355, callArgs_6); + arg3 = ((int) callResult_6[0]); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (local4 + 112)); + callArgs_8[1] = ((long) (local4 + 88)); + callArgs_8[0] = ((long) (arg0 + 24)); + long[] callResult_8 = instance.getMachine().call(298, callArgs_8); + arg0 = ((int) callResult_8[0]); + instance.global(0).setValue(((long) (local4 + 176))); + return (((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_410(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_410(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_411(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 207); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 56)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) (local3 + 79) < 0 ? (local3 + 79) : (local3 + 79) + 0, (int) 0); + memory.writeLong((int) ((local3 + 64) + 8) < 0 ? ((local3 + 64) + 8) : ((local3 + 64) + 8) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 16)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 64)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 64)); + callArgs_5[0] = ((long) (arg0 + 24)); + long[] callResult_5 = instance.getMachine().call(300, callArgs_5); + arg0 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local3 + 128))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_411(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_411(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_412(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 56); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 56)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) (local3 + 79) < 0 ? (local3 + 79) : (local3 + 79) + 0, (int) 0); + memory.writeLong((int) ((local3 + 64) + 8) < 0 ? ((local3 + 64) + 8) : ((local3 + 64) + 8) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 16)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 64)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 64)); + callArgs_5[0] = ((long) (arg0 + 24)); + long[] callResult_5 = instance.getMachine().call(301, callArgs_5); + arg0 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local3 + 128))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_412(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_412(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_413(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local4 = (((int) instance.global(0).getValue()) - 192); + instance.global(0).setValue(((long) local4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 104, (int) 204); + label_1: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 104)); + callArgs_0[0] = ((long) (local4 + 128)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local4 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) (local4 + 119) < 0 ? (local4 + 119) : (local4 + 119) + 0, (int) 0); + memory.writeLong((int) ((local4 + 104) + 8) < 0 ? ((local4 + 104) + 8) : ((local4 + 104) + 8) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local4 + 64)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local4 + 104)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + local6 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + arg1 = 0; + label_2: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local7 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local7); + callArgs_6[0] = ((long) (local4 + 128)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + arg3 = ((int) callResult_6[0]); + local8 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 24); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 232); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, local9) != 0) { + break label_2; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 6926); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local4); + callArgs_7[2] = ((long) 30023); + callArgs_7[1] = ((long) arg3); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_7[0])); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg3); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local7); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) (local4 + 104)); + callArgs_10[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + callArgs_10[0] = ((long) (arg0 + 24)); + long[] callResult_10 = instance.getMachine().call(302, callArgs_10); + arg0 = ((int) callResult_10[0]); + instance.global(0).setValue(((long) (local4 + 192))); + return (((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6)) | arg1) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_413(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_413(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_414(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 55); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 56)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) (local3 + 79) < 0 ? (local3 + 79) : (local3 + 79) + 0, (int) 0); + memory.writeLong((int) ((local3 + 64) + 8) < 0 ? ((local3 + 64) + 8) : ((local3 + 64) + 8) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 16)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 64)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local3 + 64)); + callArgs_5[0] = ((long) (arg0 + 24)); + long[] callResult_5 = instance.getMachine().call(303, callArgs_5); + arg0 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local3 + 128))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_414(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_414(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_415(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + local3 = 1; + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 1); + label_1: { + label_2: { + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF) != 0) { + break label_2; + } + local3 = 0; + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + instance.global(0).setValue(((long) (local2 + 80))); + return local3; + } + + public static long[] call_415(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_415(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_416(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (local3 + 24)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) (local3 + 64)); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + local5 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local5); + callArgs_2[0] = ((long) (local3 + 104)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg1 = ((int) callResult_2[0]); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (arg0 + 156) < 0 ? (arg0 + 156) : (arg0 + 156) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 152)), 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local7) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 12348); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local3); + callArgs_3[2] = ((long) 30023); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(337, callArgs_3); + local6 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local4); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + arg1 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local6) != 0) { + break label_2; + } + break label_1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local5); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + } + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_5; + } + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + local6 = (arg0 + 264); + arg1 = local6; + label_6: { + local4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_6; + } + label_7: while (true) { + label_8: { + arg1 = local4; + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local4) != 0) { + break label_8; + } + local6 = arg1; + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_4; + } + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + local6 = (arg1 + 4); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) 20); + long[] callResult_10 = instance.getMachine().call(1776, callArgs_10); + local4 = ((int) callResult_10[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) local5); + label_9: { + arg1 = memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 260) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 260) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 260) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_9; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 260, (int) arg1); + local4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) local4); + callArgs_11[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 264)); + instance.getMachine().call(43, callArgs_11); + arg1 = (arg0 + 268); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 1)); + break label_4; + } + label_10: { + arg1 = memory.readInt((int) (arg0 + 276) < 0 ? (arg0 + 276) : (arg0 + 276) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 280) < 0 ? (arg0 + 280) : (arg0 + 280) + 0), arg1) != 0) { + break label_10; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) arg2); + callArgs_12[0] = ((long) arg1); + long[] callResult_12 = instance.getMachine().call(159, callArgs_12); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 276, (int) (((int) callResult_12[0]) + 36)); + break label_4; + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) arg2); + callArgs_13[0] = ((long) (arg0 + 272)); + instance.getMachine().call(417, callArgs_13); + } + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)); + callArgs_14[1] = ((long) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 152) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) * 28)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 152) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) * 28)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 152) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) * 28)) + 24)); + callArgs_14[0] = ((long) (arg0 + 24)); + long[] callResult_14 = instance.getMachine().call(312, callArgs_14); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])); + } + instance.global(0).setValue(((long) (local3 + 144))); + return arg1; + } + + public static long[] call_416(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_416(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_417(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2), 36); + local4 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 119304648) != 0) { + break label_4; + } + label_5: { + label_6: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 36); + local5 = (local2 << 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, local4) != 0 ? local5 : local4) : 119304647); + if (local4 != 0) { + break label_6; + } + local2 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 119304648) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 * 36)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + } + local5 = (local2 + (local4 * 36)); + local2 = (local2 + (local3 * 36)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + local3 = ((int) callResult_1[0]); + local6 = (local3 + 36); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + local2 = (local2 + -36); + label_7: while (true) { + local4 = (local4 + -36); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(157, callArgs_2); + local3 = ((int) callResult_2[0]); + local2 = (local2 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_1; + } + local2 = (local2 + -36); + label_8: while (true) { + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + arg1 = ((int) callResult_3[0]); + local2 = (local2 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_9; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_6); + } + return; + } + + public static long[] call_417(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_417(arg0, arg1, memory, instance); + return null; + } + + public static int func_418(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 217); + label_1: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(314, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_418(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_418(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_419(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + local4 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) local4); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (arg0 + 24)); + long[] callResult_0 = instance.getMachine().call(313, callArgs_0); + arg0 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0); + } + + public static long[] call_419(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_419(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_420(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) 9); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) (local3 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(315, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local3 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_420(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_420(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_421(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) 18); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 48)); + callArgs_0[0] = ((long) (local3 + 80)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 80)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeLong((int) ((local3 + 48) + 16) < 0 ? ((local3 + 48) + 16) : ((local3 + 48) + 16) + 0, (long) 0L); + memory.writeLong((int) ((local3 + 48) + 8) < 0 ? ((local3 + 48) + 8) : ((local3 + 48) + 8) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 8)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) (local3 + 80)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) 12348); + callArgs_4[3] = ((long) (local3 + 48)); + callArgs_4[2] = ((long) (arg0 + 152)); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(356, callArgs_4); + local5 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg2); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local3 + 60)); + callArgs_7[1] = ((long) (local3 + 48)); + callArgs_7[0] = ((long) (arg0 + 24)); + long[] callResult_7 = instance.getMachine().call(279, callArgs_7); + arg1 = ((int) callResult_7[0]); + label_2: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) (local3 + 64) < 0 ? (local3 + 64) : (local3 + 64) + 0, (int) arg0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_8); + } + label_3: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) arg0); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_9); + } + instance.global(0).setValue(((long) (local3 + 144))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)); + } + + public static long[] call_421(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_421(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_422(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local4 = (((int) instance.global(0).getValue()) - 240); + instance.global(0).setValue(((long) local4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 200, (int) 17); + label_1: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 200)); + callArgs_0[0] = ((long) (local4 + 136)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 136)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local4 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeLong((int) ((local4 + 104) + 16) < 0 ? ((local4 + 104) + 16) : ((local4 + 104) + 16) + 0, (long) 0L); + memory.writeLong((int) ((local4 + 104) + 8) < 0 ? ((local4 + 104) + 8) : ((local4 + 104) + 8) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local4 + 64)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local4 + 104)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(342, callArgs_3); + local6 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6)); + label_2: { + label_3: { + label_4: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg3); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local6 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local6); + callArgs_6[0] = ((long) (local4 + 200)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + arg3 = ((int) callResult_6[0]); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg3); + callArgs_7[0] = ((long) (local4 + 136)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + arg2 = ((int) callResult_7[0]); + local7 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + local8 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, local8) != 0) { + break label_4; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local7); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 17326); + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) local4); + callArgs_8[2] = ((long) 30023); + callArgs_8[1] = ((long) arg2); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + local7 = ((int) callResult_8[0]); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg2); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_3; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7); + local7 = 0; + break label_2; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-16, memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 24) << 5)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 24) << 5)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 24) << 5)) + 0)); + arg2 = 0; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg3); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local6); + long[] callResult_12 = instance.getMachine().call(162, callArgs_12); + arg3 = (local5 | arg2); + label_5: { + if (local7 != 0) { + break label_5; + } + long[] callArgs_13 = new long[4]; + callArgs_13[3] = ((long) 0); + callArgs_13[2] = ((long) 15988); + callArgs_13[1] = ((long) arg1); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(337, callArgs_13); + arg3 = (arg3 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_13[0]))); + } + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) (local4 + 116)); + callArgs_14[1] = ((long) (local4 + 104)); + callArgs_14[0] = ((long) (arg0 + 24)); + long[] callResult_14 = instance.getMachine().call(280, callArgs_14); + arg1 = ((int) callResult_14[0]); + label_6: { + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 116); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_6; + } + memory.writeI32((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0, (int) arg0); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_15); + } + label_7: { + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 104); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_7; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 108, (int) arg0); + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_16); + } + instance.global(0).setValue(((long) (local4 + 240))); + return (arg3 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)); + } + + public static long[] call_422(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_422(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_423(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 15); + label_1: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(318, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_423(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_423(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_424(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) 24); + label_1: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 24)); + callArgs_0[0] = ((long) (local4 + 32)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 32)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local4 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 2) != 0) { + break label_3; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg2); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local4); + callArgs_2[2] = ((long) 28815); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(337, callArgs_2); + arg0 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0]))); + break label_2; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 40, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 32, (long) 0L); + arg0 = (arg0 + 24); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_4; + } + arg1 = (arg2 << 3); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg2 = ((int) callResult_3[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) arg2); + local6 = (arg2 + arg1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 40, (int) local6); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg1); + callArgs_4[1] = ((long) arg3); + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(1890, callArgs_4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) local6); + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local4 + 32)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(319, callArgs_5); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])); + label_5: { + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) arg0); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_6); + } + arg0 = (arg1 | arg2); + } + instance.global(0).setValue(((long) (local4 + 96))); + return arg0; + } + + public static long[] call_424(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_424(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_425(int arg0, int arg1, int arg2, long arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg2); + local5 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local6 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 30) != 0) { + break label_2; + } + if (((1 << local6) & 2013265921) != 0) { + break label_1; + } + } + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + local6 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 21) != 0) { + break label_4; + } + if (((1835015 >>> local6) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 8)); + callArgs_0[0] = ((long) (local4 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local4); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local5 = 1; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = arg3; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(327, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local4 + 80))); + return (local5 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_425(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + int result = Wat2WasmMachine.func_425(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_426(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, long arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + local7 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local7)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 80, (int) arg2); + local8 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local9 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, 30) != 0) { + break label_2; + } + local8 = 0; + if (((1 << local9) & 2013265921) != 0) { + break label_1; + } + } + local8 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local8 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local7 + 80)); + callArgs_0[0] = ((long) (local7 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local7 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local8 = 1; + } + memory.writeI32((int) (local7 + 95) < 0 ? (local7 + 95) : (local7 + 95) + 0, (int) 0); + memory.writeLong((int) ((local7 + 80) + 8) < 0 ? ((local7 + 80) + 8) : ((local7 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local7 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local7 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local7 + 104)); + callArgs_5[0] = ((long) (local7 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local7 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local10 = memory.readLong((int) local7 < 0 ? local7 : local7 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(local10, arg4) != 0) { + break label_5; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) local10); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local7); + callArgs_7[2] = ((long) 29741); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local7 < 0 ? local7 : local7 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local9) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[4]; + callArgs_9[3] = arg6; + callArgs_9[2] = ((long) (local7 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(328, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local7 + 176))); + return ((((local8 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local9) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_426(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + long arg6 = args[6]; + int result = Wat2WasmMachine.func_426(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_427(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, long arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + local7 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local7)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 80, (int) arg2); + local8 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local9 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, 30) != 0) { + break label_2; + } + local8 = 0; + if (((1 << local9) & 2013265921) != 0) { + break label_1; + } + } + local8 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local8 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local7 + 80)); + callArgs_0[0] = ((long) (local7 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local7 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local8 = 1; + } + memory.writeI32((int) (local7 + 95) < 0 ? (local7 + 95) : (local7 + 95) + 0, (int) 0); + memory.writeLong((int) ((local7 + 80) + 8) < 0 ? ((local7 + 80) + 8) : ((local7 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local7 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local7 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local7 + 104)); + callArgs_5[0] = ((long) (local7 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local7 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local10 = memory.readLong((int) local7 < 0 ? local7 : local7 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(local10, arg4) != 0) { + break label_5; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) local10); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local7); + callArgs_7[2] = ((long) 29741); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local7 < 0 ? local7 : local7 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local9) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[4]; + callArgs_9[3] = arg6; + callArgs_9[2] = ((long) (local7 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(329, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local7 + 176))); + return ((((local8 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local9) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_427(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + long arg6 = args[6]; + int result = Wat2WasmMachine.func_427(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_428(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) arg2); + local5 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local6 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 30) != 0) { + break label_2; + } + if (((1 << local6) & 2013265921) != 0) { + break label_1; + } + } + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + local6 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 21) != 0) { + break label_4; + } + if (((1835015 >>> local6) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 24)); + callArgs_0[0] = ((long) (local4 + 32)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 32)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local4 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local5 = 1; + } + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(330, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local4 + 96))); + return (local5 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_428(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_428(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_429(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 104, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg2); + local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local8 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 30) != 0) { + break label_2; + } + local7 = 0; + if (((1 << local8) & 2013265921) != 0) { + break label_1; + } + } + local7 = 0; + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + arg2 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 21) != 0) { + break label_4; + } + local7 = 0; + if (((1835015 >>> arg2) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local6 + 80)); + callArgs_0[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 112)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local6 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local7 = 1; + } + memory.writeI32((int) (local6 + 95) < 0 ? (local6 + 95) : (local6 + 95) + 0, (int) 0); + memory.writeLong((int) ((local6 + 80) + 8) < 0 ? ((local6 + 80) + 8) : ((local6 + 80) + 8) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 80, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local6 + 40)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 + 80)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(355, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 104)); + callArgs_5[0] = ((long) (local6 + 112)); + instance.getMachine().call(192, callArgs_5); + label_5: { + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT((int) arg4)) != 0) { + break label_7; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 16, (long) arg4); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local6 + 16)); + callArgs_6[2] = ((long) 28400); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(337, callArgs_6); + break label_6; + } + arg2 = 0; + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(local9, arg4) != 0) { + break label_5; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local6); + callArgs_7[2] = ((long) 29741); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(337, callArgs_7); + } + arg2 = 1; + } + label_8: { + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(arg5, 4294967295L) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 98) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 14764); + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(337, callArgs_8); + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local6 + 80)); + callArgs_9[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 104)); + callArgs_9[0] = ((long) (arg0 + 24)); + long[] callResult_9 = instance.getMachine().call(320, callArgs_9); + arg0 = ((int) callResult_9[0]); + instance.global(0).setValue(((long) (local6 + 176))); + return ((((local7 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | arg2) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_429(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_429(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_430(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + long local12 = 0L; + long local13 = 0L; + local4 = (((int) instance.global(0).getValue()) - 352); + instance.global(0).setValue(((long) local4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 280, (int) 210); + label_1: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 280)); + callArgs_0[0] = ((long) (local4 + 216)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 48, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 216)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local4 + 48)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeLong((int) ((local4 + 184) + 16) < 0 ? ((local4 + 184) + 16) : ((local4 + 184) + 16) + 0, (long) 0L); + memory.writeI32((int) ((local4 + 184) + 23) < 0 ? ((local4 + 184) + 23) : ((local4 + 184) + 23) + 0, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 192, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 184, (long) -4294967296L); + memory.writeLong((int) ((local4 + 152) + 16) < 0 ? ((local4 + 152) + 16) : ((local4 + 152) + 16) + 0, (long) 0L); + memory.writeI32((int) ((local4 + 152) + 23) < 0 ? ((local4 + 152) + 23) : ((local4 + 152) + 23) + 0, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 160, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 152, (long) -4294967296L); + local6 = ((local4 + 184) + 8); + label_2: { + label_3: { + label_4: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local4 + 112)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local7 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local4 + 280)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local8 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local8); + callArgs_4[0] = ((long) (local4 + 216)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg2 = ((int) callResult_4[0]); + local9 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + local10 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, local10) != 0) { + break label_4; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 40, (int) local10); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 17326); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local4 + 32)); + callArgs_5[2] = ((long) 30023); + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local10 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg2); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_3; + } + local9 = 0; + memory.writeByte((int) (local4 + 324) < 0 ? (local4 + 324) : (local4 + 324) + 0, (byte) (0)); + memory.writeLong((int) (local4 + 336) < 0 ? (local4 + 336) : (local4 + 336) + 0, (long) 0L); + memory.writeI32((int) (local4 + 343) < 0 ? (local4 + 343) : (local4 + 343) + 0, (int) 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 320, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 328, (long) 0L); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local10); + local11 = -1; + break label_2; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg2); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + } + arg2 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) local8 < 0 ? local8 : local8 + 24) << 5)); + memory.writeLong((int) (local4 + 336) < 0 ? (local4 + 336) : (local4 + 336) + 0, (long) memory.readLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + memory.writeI32((int) (local4 + 343) < 0 ? (local4 + 343) : (local4 + 343) + 0, (int) memory.readInt((int) (arg2 + 23) < 0 ? (arg2 + 23) : (arg2 + 23) + 0)); + memory.writeByte((int) (local4 + 324) < 0 ? (local4 + 324) : (local4 + 324) + 0, (byte) (((int) memory.read((int) (arg2 + 31) < 0 ? (arg2 + 31) : (arg2 + 31) + 0) & 0xFF))); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 328, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 8)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 320, (int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 27)); + local11 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + local9 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local10 = 0; + } + arg2 = ((local4 + 152) + 8); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 328)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) ((local4 + 328) + 8) < 0 ? ((local4 + 328) + 8) : ((local4 + 328) + 8) + 0)); + memory.writeI32((int) (local6 + 15) < 0 ? (local6 + 15) : (local6 + 15) + 0, (int) memory.readInt((int) ((local4 + 328) + 15) < 0 ? ((local4 + 328) + 15) : ((local4 + 328) + 15) + 0)); + memory.writeByte((int) (local4 + 215) < 0 ? (local4 + 215) : (local4 + 215) + 0, (byte) (((int) memory.read((int) (local4 + 324) < 0 ? (local4 + 324) : (local4 + 324) + 0) & 0xFF))); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 188, (int) local11); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 184, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 211, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 320)); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local8); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local7); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + label_5: { + label_6: { + label_7: { + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) arg3); + callArgs_10[0] = ((long) (local4 + 72)); + long[] callResult_10 = instance.getMachine().call(159, callArgs_10); + local7 = ((int) callResult_10[0]); + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) local7); + callArgs_11[0] = ((long) (local4 + 280)); + long[] callResult_11 = instance.getMachine().call(159, callArgs_11); + arg3 = ((int) callResult_11[0]); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) arg3); + callArgs_12[0] = ((long) (local4 + 216)); + long[] callResult_12 = instance.getMachine().call(159, callArgs_12); + local8 = ((int) callResult_12[0]); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local11 = ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 168) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, local11) != 0) { + break label_7; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) local11); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) 17326); + long[] callArgs_13 = new long[4]; + callArgs_13[3] = ((long) (local4 + 16)); + callArgs_13[2] = ((long) 30023); + callArgs_13[1] = ((long) local8); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(337, callArgs_13); + local9 = ((int) callResult_13[0]); + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local8); + long[] callResult_14 = instance.getMachine().call(162, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_6; + } + local8 = 0; + memory.writeByte((int) (local4 + 324) < 0 ? (local4 + 324) : (local4 + 324) + 0, (byte) (0)); + memory.writeLong((int) (local4 + 336) < 0 ? (local4 + 336) : (local4 + 336) + 0, (long) 0L); + memory.writeI32((int) (local4 + 343) < 0 ? (local4 + 343) : (local4 + 343) + 0, (int) 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 320, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 328, (long) 0L); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local9); + local11 = -1; + break label_5; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local8); + long[] callResult_15 = instance.getMachine().call(162, callArgs_15); + } + local8 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 24) << 5)); + memory.writeLong((int) (local4 + 336) < 0 ? (local4 + 336) : (local4 + 336) + 0, (long) memory.readLong((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0)); + memory.writeI32((int) (local4 + 343) < 0 ? (local4 + 343) : (local4 + 343) + 0, (int) memory.readInt((int) (local8 + 23) < 0 ? (local8 + 23) : (local8 + 23) + 0)); + memory.writeByte((int) (local4 + 324) < 0 ? (local4 + 324) : (local4 + 324) + 0, (byte) (((int) memory.read((int) (local8 + 31) < 0 ? (local8 + 31) : (local8 + 31) + 0) & 0xFF))); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 328, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 8)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 320, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 27)); + local11 = memory.readInt((int) local8 < 0 ? local8 : local8 + 4); + local8 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local9 = 0; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 328)); + memory.writeLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (long) memory.readLong((int) ((local4 + 328) + 8) < 0 ? ((local4 + 328) + 8) : ((local4 + 328) + 8) + 0)); + memory.writeI32((int) (arg2 + 15) < 0 ? (arg2 + 15) : (arg2 + 15) + 0, (int) memory.readInt((int) ((local4 + 328) + 15) < 0 ? ((local4 + 328) + 15) : ((local4 + 328) + 15) + 0)); + memory.writeByte((int) (local4 + 183) < 0 ? (local4 + 183) : (local4 + 183) + 0, (byte) (((int) memory.read((int) (local4 + 324) < 0 ? (local4 + 324) : (local4 + 324) + 0) & 0xFF))); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 156, (int) local11); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 152, (int) local8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 179, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 320)); + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) arg3); + long[] callResult_16 = instance.getMachine().call(162, callArgs_16); + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local7); + long[] callResult_17 = instance.getMachine().call(162, callArgs_17); + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) arg2); + callArgs_18[1] = ((long) local6); + callArgs_18[0] = ((long) (arg0 + 24)); + long[] callResult_18 = instance.getMachine().call(304, callArgs_18); + local6 = ((int) callResult_18[0]); + local12 = memory.readLong((int) local4 < 0 ? local4 : local4 + 152); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 64, (long) local12); + local13 = memory.readLong((int) local4 < 0 ? local4 : local4 + 184); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 56, (long) local13); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local12); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) local13); + long[] callArgs_19 = new long[5]; + callArgs_19[4] = ((long) 1260); + callArgs_19[3] = ((long) local4); + callArgs_19[2] = ((long) (local4 + 8)); + callArgs_19[1] = ((long) arg1); + callArgs_19[0] = ((long) arg0); + long[] callResult_19 = instance.getMachine().call(349, callArgs_19); + arg0 = ((int) callResult_19[0]); + instance.global(0).setValue(((long) (local4 + 352))); + return ((((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | local10) | local9) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_430(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_430(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_431(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local3 = (((int) instance.global(0).getValue()) - 256); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 184, (int) 215); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 184)); + callArgs_0[0] = ((long) (local3 + 120)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 120)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + label_2: { + label_3: { + label_4: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 48)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local3 + 184)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local3 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg1 = ((int) callResult_4[0]); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local7 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local7) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) 17326); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local3 + 16)); + callArgs_5[2] = ((long) 30023); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local6 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + arg1 = 0; + memory.writeByte((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0, (byte) (0)); + memory.writeLong((int) (local3 + 240) < 0 ? (local3 + 240) : (local3 + 240) + 0, (long) 0L); + memory.writeI32((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0, (int) 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 224, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 232, (long) 0L); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6); + local7 = -1; + break label_2; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + } + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) << 5)); + memory.writeLong((int) (local3 + 240) < 0 ? (local3 + 240) : (local3 + 240) + 0, (long) memory.readLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0, (int) memory.readInt((int) (arg1 + 23) < 0 ? (arg1 + 23) : (arg1 + 23) + 0)); + memory.writeByte((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0, (byte) (((int) memory.read((int) (arg1 + 31) < 0 ? (arg1 + 31) : (arg1 + 31) + 0) & 0xFF))); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 232, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 8)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 224, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 27)); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = 0; + } + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) memory.readLong((int) ((local3 + 232) + 8) < 0 ? ((local3 + 232) + 8) : ((local3 + 232) + 8) + 0)); + memory.writeI32((int) (local3 + 111) < 0 ? (local3 + 111) : (local3 + 111) + 0, (int) memory.readInt((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0)); + memory.writeByte((int) (local3 + 119) < 0 ? (local3 + 119) : (local3 + 119) + 0, (byte) (((int) memory.read((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0) & 0xFF))); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 92, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 96, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 232)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 115, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 224)); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg2); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local5); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + local8 = memory.readLong((int) local3 < 0 ? local3 : local3 + 88); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local8); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) ((local3 + 88) + 8)); + callArgs_10[1] = ((long) (local3 + 8)); + callArgs_10[0] = ((long) (arg0 + 24)); + long[] callResult_10 = instance.getMachine().call(311, callArgs_10); + arg0 = ((int) callResult_10[0]); + instance.global(0).setValue(((long) (local3 + 256))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | local6) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_431(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_431(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_432(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local3 = (((int) instance.global(0).getValue()) - 256); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 184, (int) 211); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 184)); + callArgs_0[0] = ((long) (local3 + 120)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 120)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + label_2: { + label_3: { + label_4: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 48)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local3 + 184)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local3 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg1 = ((int) callResult_4[0]); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local7 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local7) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) 17326); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local3 + 16)); + callArgs_5[2] = ((long) 30023); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local6 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + arg1 = 0; + memory.writeByte((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0, (byte) (0)); + memory.writeLong((int) (local3 + 240) < 0 ? (local3 + 240) : (local3 + 240) + 0, (long) 0L); + memory.writeI32((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0, (int) 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 224, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 232, (long) 0L); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6); + local7 = -1; + break label_2; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + } + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) << 5)); + memory.writeLong((int) (local3 + 240) < 0 ? (local3 + 240) : (local3 + 240) + 0, (long) memory.readLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0, (int) memory.readInt((int) (arg1 + 23) < 0 ? (arg1 + 23) : (arg1 + 23) + 0)); + memory.writeByte((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0, (byte) (((int) memory.read((int) (arg1 + 31) < 0 ? (arg1 + 31) : (arg1 + 31) + 0) & 0xFF))); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 232, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 8)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 224, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 27)); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = 0; + } + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) memory.readLong((int) ((local3 + 232) + 8) < 0 ? ((local3 + 232) + 8) : ((local3 + 232) + 8) + 0)); + memory.writeI32((int) (local3 + 111) < 0 ? (local3 + 111) : (local3 + 111) + 0, (int) memory.readInt((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0)); + memory.writeByte((int) (local3 + 119) < 0 ? (local3 + 119) : (local3 + 119) + 0, (byte) (((int) memory.read((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0) & 0xFF))); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 92, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 96, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 232)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 115, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 224)); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg2); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local5); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + local8 = memory.readLong((int) local3 < 0 ? local3 : local3 + 88); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local8); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) ((local3 + 88) + 8)); + callArgs_10[1] = ((long) (local3 + 8)); + callArgs_10[0] = ((long) (arg0 + 24)); + long[] callResult_10 = instance.getMachine().call(307, callArgs_10); + arg0 = ((int) callResult_10[0]); + instance.global(0).setValue(((long) (local3 + 256))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | local6) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_432(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_432(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_433(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local3 = (((int) instance.global(0).getValue()) - 256); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 184, (int) 213); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 184)); + callArgs_0[0] = ((long) (local3 + 120)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 120)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + label_2: { + label_3: { + label_4: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 48)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local3 + 184)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local3 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg1 = ((int) callResult_4[0]); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local7 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local7) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) 17326); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local3 + 16)); + callArgs_5[2] = ((long) 30023); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local6 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + arg1 = 0; + memory.writeByte((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0, (byte) (0)); + memory.writeLong((int) (local3 + 240) < 0 ? (local3 + 240) : (local3 + 240) + 0, (long) 0L); + memory.writeI32((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0, (int) 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 224, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 232, (long) 0L); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6); + local7 = -1; + break label_2; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + } + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) << 5)); + memory.writeLong((int) (local3 + 240) < 0 ? (local3 + 240) : (local3 + 240) + 0, (long) memory.readLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0, (int) memory.readInt((int) (arg1 + 23) < 0 ? (arg1 + 23) : (arg1 + 23) + 0)); + memory.writeByte((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0, (byte) (((int) memory.read((int) (arg1 + 31) < 0 ? (arg1 + 31) : (arg1 + 31) + 0) & 0xFF))); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 232, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 8)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 224, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 27)); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = 0; + } + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) memory.readLong((int) ((local3 + 232) + 8) < 0 ? ((local3 + 232) + 8) : ((local3 + 232) + 8) + 0)); + memory.writeI32((int) (local3 + 111) < 0 ? (local3 + 111) : (local3 + 111) + 0, (int) memory.readInt((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0)); + memory.writeByte((int) (local3 + 119) < 0 ? (local3 + 119) : (local3 + 119) + 0, (byte) (((int) memory.read((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0) & 0xFF))); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 92, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 96, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 232)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 115, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 224)); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg2); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local5); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + local8 = memory.readLong((int) local3 < 0 ? local3 : local3 + 88); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local8); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) ((local3 + 88) + 8)); + callArgs_10[1] = ((long) (local3 + 8)); + callArgs_10[0] = ((long) (arg0 + 24)); + long[] callResult_10 = instance.getMachine().call(309, callArgs_10); + arg0 = ((int) callResult_10[0]); + instance.global(0).setValue(((long) (local3 + 256))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | local6) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_433(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_433(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_434(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + long local11 = 0L; + local4 = (((int) instance.global(0).getValue()) - 304); + instance.global(0).setValue(((long) local4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 232, (int) 208); + label_1: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 232)); + callArgs_0[0] = ((long) (local4 + 168)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 168)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local4 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 136, (int) 0); + label_2: { + label_3: { + label_4: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local4 + 96)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local6 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local6); + callArgs_3[0] = ((long) (local4 + 232)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local7 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local7); + callArgs_4[0] = ((long) (local4 + 168)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg3 = ((int) callResult_4[0]); + local8 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 24); + local9 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, local9) != 0) { + break label_4; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) local8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) 17326); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local4 + 16)); + callArgs_5[2] = ((long) 30023); + callArgs_5[1] = ((long) arg3); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local8 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg3); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_3; + } + arg3 = 0; + memory.writeByte((int) (local4 + 276) < 0 ? (local4 + 276) : (local4 + 276) + 0, (byte) (0)); + memory.writeLong((int) (local4 + 288) < 0 ? (local4 + 288) : (local4 + 288) + 0, (long) 0L); + memory.writeI32((int) (local4 + 295) < 0 ? (local4 + 295) : (local4 + 295) + 0, (int) 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 272, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 280, (long) 0L); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local8); + local9 = -1; + break label_2; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg3); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + } + arg3 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) local7 < 0 ? local7 : local7 + 24) << 5)); + memory.writeLong((int) (local4 + 288) < 0 ? (local4 + 288) : (local4 + 288) + 0, (long) memory.readLong((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0)); + memory.writeI32((int) (local4 + 295) < 0 ? (local4 + 295) : (local4 + 295) + 0, (int) memory.readInt((int) (arg3 + 23) < 0 ? (arg3 + 23) : (arg3 + 23) + 0)); + memory.writeByte((int) (local4 + 276) < 0 ? (local4 + 276) : (local4 + 276) + 0, (byte) (((int) memory.read((int) (arg3 + 31) < 0 ? (arg3 + 31) : (arg3 + 31) + 0) & 0xFF))); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 280, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 8)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 272, (int) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 27)); + local9 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + arg3 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + local8 = 0; + } + memory.writeLong((int) (local4 + 152) < 0 ? (local4 + 152) : (local4 + 152) + 0, (long) memory.readLong((int) ((local4 + 280) + 8) < 0 ? ((local4 + 280) + 8) : ((local4 + 280) + 8) + 0)); + memory.writeI32((int) (local4 + 159) < 0 ? (local4 + 159) : (local4 + 159) + 0, (int) memory.readInt((int) (local4 + 295) < 0 ? (local4 + 295) : (local4 + 295) + 0)); + memory.writeByte((int) (local4 + 167) < 0 ? (local4 + 167) : (local4 + 167) + 0, (byte) (((int) memory.read((int) (local4 + 276) < 0 ? (local4 + 276) : (local4 + 276) + 0) & 0xFF))); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 140, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 136, (int) arg3); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 144, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 280)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 163, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 272)); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local7); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local6); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) arg2); + callArgs_10[0] = ((long) (local4 + 56)); + long[] callResult_10 = instance.getMachine().call(159, callArgs_10); + arg3 = ((int) callResult_10[0]); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local4 + 168)); + callArgs_11[1] = ((long) arg3); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(365, callArgs_11); + local7 = ((int) callResult_11[0]); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) arg3); + long[] callResult_12 = instance.getMachine().call(162, callArgs_12); + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) ((local4 + 136) + 8)); + callArgs_13[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + callArgs_13[0] = ((long) (arg0 + 24)); + long[] callResult_13 = instance.getMachine().call(306, callArgs_13); + arg3 = ((int) callResult_13[0]); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 168); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 48, (long) local10); + local11 = memory.readLong((int) local4 < 0 ? local4 : local4 + 136); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local11); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local10); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) local11); + long[] callArgs_14 = new long[5]; + callArgs_14[4] = ((long) 7157); + callArgs_14[3] = ((long) local4); + callArgs_14[2] = ((long) (local4 + 8)); + callArgs_14[1] = ((long) arg1); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(349, callArgs_14); + arg0 = ((int) callResult_14[0]); + instance.global(0).setValue(((long) (local4 + 304))); + return ((((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5) | local8) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_434(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_434(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_435(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local3 = (((int) instance.global(0).getValue()) - 256); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 184, (int) 212); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 184)); + callArgs_0[0] = ((long) (local3 + 120)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 120)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 32)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + label_2: { + label_3: { + label_4: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 48)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local3 + 184)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local3 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg1 = ((int) callResult_4[0]); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local7 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local7) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) 17326); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local3 + 16)); + callArgs_5[2] = ((long) 30023); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local6 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + arg1 = 0; + memory.writeByte((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0, (byte) (0)); + memory.writeLong((int) (local3 + 240) < 0 ? (local3 + 240) : (local3 + 240) + 0, (long) 0L); + memory.writeI32((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0, (int) 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 224, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 232, (long) 0L); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6); + local7 = -1; + break label_2; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + } + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) << 5)); + memory.writeLong((int) (local3 + 240) < 0 ? (local3 + 240) : (local3 + 240) + 0, (long) memory.readLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0, (int) memory.readInt((int) (arg1 + 23) < 0 ? (arg1 + 23) : (arg1 + 23) + 0)); + memory.writeByte((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0, (byte) (((int) memory.read((int) (arg1 + 31) < 0 ? (arg1 + 31) : (arg1 + 31) + 0) & 0xFF))); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 232, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 8)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 224, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 27)); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = 0; + } + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) memory.readLong((int) ((local3 + 232) + 8) < 0 ? ((local3 + 232) + 8) : ((local3 + 232) + 8) + 0)); + memory.writeI32((int) (local3 + 111) < 0 ? (local3 + 111) : (local3 + 111) + 0, (int) memory.readInt((int) (local3 + 247) < 0 ? (local3 + 247) : (local3 + 247) + 0)); + memory.writeByte((int) (local3 + 119) < 0 ? (local3 + 119) : (local3 + 119) + 0, (byte) (((int) memory.read((int) (local3 + 228) < 0 ? (local3 + 228) : (local3 + 228) + 0) & 0xFF))); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 92, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 96, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 232)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 115, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 224)); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg2); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local5); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + local8 = memory.readLong((int) local3 < 0 ? local3 : local3 + 88); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local8); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) ((local3 + 88) + 8)); + callArgs_10[1] = ((long) (local3 + 8)); + callArgs_10[0] = ((long) (arg0 + 24)); + long[] callResult_10 = instance.getMachine().call(308, callArgs_10); + arg0 = ((int) callResult_10[0]); + instance.global(0).setValue(((long) (local3 + 256))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | local6) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_435(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_435(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_436(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 240); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 168, (int) 214); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 168)); + callArgs_0[0] = ((long) (local3 + 104)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 104)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + label_2: { + label_3: { + label_4: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 32)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local3 + 168)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local3 + 104)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg1 = ((int) callResult_4[0]); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local7 = ((memory.readInt((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0) - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164)) >> 5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local7) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 17326); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) local3); + callArgs_5[2] = ((long) 30023); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(337, callArgs_5); + local6 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + arg1 = 0; + memory.writeByte((int) (local3 + 212) < 0 ? (local3 + 212) : (local3 + 212) + 0, (byte) (0)); + memory.writeLong((int) (local3 + 224) < 0 ? (local3 + 224) : (local3 + 224) + 0, (long) 0L); + memory.writeI32((int) (local3 + 231) < 0 ? (local3 + 231) : (local3 + 231) + 0, (int) 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 208, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 216, (long) 0L); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6); + local7 = -1; + break label_2; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + } + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164) + (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24) << 5)); + memory.writeLong((int) (local3 + 224) < 0 ? (local3 + 224) : (local3 + 224) + 0, (long) memory.readLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) (local3 + 231) < 0 ? (local3 + 231) : (local3 + 231) + 0, (int) memory.readInt((int) (arg1 + 23) < 0 ? (arg1 + 23) : (arg1 + 23) + 0)); + memory.writeByte((int) (local3 + 212) < 0 ? (local3 + 212) : (local3 + 212) + 0, (byte) (((int) memory.read((int) (arg1 + 31) < 0 ? (arg1 + 31) : (arg1 + 31) + 0) & 0xFF))); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 216, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 8)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 208, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 27)); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = 0; + } + memory.writeLong((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0, (long) memory.readLong((int) ((local3 + 216) + 8) < 0 ? ((local3 + 216) + 8) : ((local3 + 216) + 8) + 0)); + memory.writeI32((int) (local3 + 95) < 0 ? (local3 + 95) : (local3 + 95) + 0, (int) memory.readInt((int) (local3 + 231) < 0 ? (local3 + 231) : (local3 + 231) + 0)); + memory.writeByte((int) (local3 + 103) < 0 ? (local3 + 103) : (local3 + 103) + 0, (byte) (((int) memory.read((int) (local3 + 212) < 0 ? (local3 + 212) : (local3 + 212) + 0) & 0xFF))); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 76, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 72, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 80, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 216)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 99, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 208)); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg2); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local5); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) ((local3 + 72) + 8)); + callArgs_10[0] = ((long) (arg0 + 24)); + long[] callResult_10 = instance.getMachine().call(310, callArgs_10); + arg0 = ((int) callResult_10[0]); + instance.global(0).setValue(((long) (local3 + 240))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | local6) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_436(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_436(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_437(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg2); + local4 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local5 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 30) != 0) { + break label_2; + } + if (((1 << local5) & 2013265921) != 0) { + break label_1; + } + } + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + local5 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 21) != 0) { + break label_4; + } + if (((1835015 >>> local5) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) (local3 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local4 = 1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(326, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local3 + 80))); + return (local4 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_437(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_437(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_438(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) 8); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 48)); + callArgs_0[0] = ((long) (local3 + 64)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 64)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 8)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) (local3 + 64)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) 14710); + callArgs_4[3] = ((long) (local3 + 48)); + callArgs_4[2] = ((long) (arg0 + 200)); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(358, callArgs_4); + local5 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg2); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) (local3 + 48)); + callArgs_7[0] = ((long) (arg0 + 24)); + long[] callResult_7 = instance.getMachine().call(316, callArgs_7); + arg1 = ((int) callResult_7[0]); + label_2: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) arg0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local3 + 128))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)); + } + + public static long[] call_438(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_438(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_439(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 10); + label_1: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(317, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_439(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_439(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_440(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 6); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 32)); + callArgs_0[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) 0L); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local5); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = ((long) (local3 + 32)); + callArgs_2[4] = ((long) (local3 + 48)); + callArgs_2[3] = ((long) (local3 + 8)); + callArgs_2[2] = ((long) 6); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(366, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 32)); + callArgs_3[1] = ((long) (local3 + 48)); + callArgs_3[0] = ((long) (arg0 + 24)); + long[] callResult_3 = instance.getMachine().call(321, callArgs_3); + arg2 = ((int) callResult_3[0]); + label_2: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + } + label_3: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) arg0); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local3 + 112))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)); + } + + public static long[] call_440(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_440(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_441(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 26); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 32)); + callArgs_0[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) 0L); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local5); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = ((long) (local3 + 32)); + callArgs_2[4] = ((long) (local3 + 48)); + callArgs_2[3] = ((long) (local3 + 8)); + callArgs_2[2] = ((long) 26); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(366, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 48)); + callArgs_3[0] = ((long) (arg0 + 24)); + long[] callResult_3 = instance.getMachine().call(322, callArgs_3); + arg2 = ((int) callResult_3[0]); + label_2: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + } + label_3: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) arg0); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local3 + 112))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)); + } + + public static long[] call_441(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_441(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_442(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + local4 = 0; + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) 0L); + label_1: { + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 92); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(2, (arg1 & -2)) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg2 + 20)); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local3 + 56)); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + local5 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) 14710); + callArgs_2[3] = ((long) (local3 + 40)); + callArgs_2[2] = ((long) (arg0 + 200)); + callArgs_2[1] = ((long) local5); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(358, callArgs_2); + local6 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local5); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 92); + } + label_2: { + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, (arg1 & -3)) != 0) { + break label_4; + } + label_5: { + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 44); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local5) != 0) { + break label_5; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) -23L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 44, (int) (arg1 + 8)); + break label_4; + } + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 40); + local7 = ((arg1 - local6) >> 3); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 536870912) != 0) { + break label_3; + } + label_6: { + label_7: { + local5 = (local5 - local6); + local9 = (local5 >>> 2); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 536870911); + if (local8 != 0) { + break label_7; + } + local9 = 0; + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 536870912) != 0) { + break label_2; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) (local8 << 3)); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + local9 = ((int) callResult_5[0]); + } + local5 = (local9 + (local7 << 3)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) -23L); + local8 = (local9 + (local8 << 3)); + local9 = (local5 + 8); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, arg1) != 0) { + break label_8; + } + label_9: while (true) { + local5 = (local5 + -8); + arg1 = (arg1 + -8); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 40); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 44, (int) local9); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_4; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_6); + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) memory.readInt((int) (arg2 + 80) < 0 ? (arg2 + 80) : (arg2 + 80) + 0)); + callArgs_7[1] = ((long) (local3 + 40)); + callArgs_7[0] = ((long) (arg0 + 24)); + long[] callResult_7 = instance.getMachine().call(323, callArgs_7); + local5 = ((int) callResult_7[0]); + label_10: { + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_10; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 44, (int) arg1); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local3 + 96))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_442(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_442(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_443(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 26); + label_1: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 32)); + callArgs_0[0] = ((long) (local3 + 48)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 16)); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) 0L); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local5); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = ((long) (local3 + 32)); + callArgs_2[4] = ((long) (local3 + 48)); + callArgs_2[3] = ((long) (local3 + 8)); + callArgs_2[2] = ((long) 26); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(366, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 32)); + callArgs_3[1] = ((long) (local3 + 48)); + callArgs_3[0] = ((long) (arg0 + 24)); + long[] callResult_3 = instance.getMachine().call(324, callArgs_3); + arg2 = ((int) callResult_3[0]); + label_2: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + } + label_3: { + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 52, (int) arg0); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local3 + 112))); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2)); + } + + public static long[] call_443(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_443(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_444(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg2); + local4 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF)) != 0) { + break label_1; + } + label_2: { + local5 = (arg2 + -30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 30) != 0) { + break label_2; + } + if (((1 << local5) & 2013265921) != 0) { + break label_1; + } + } + label_3: { + switch((arg2 + -216)) { + case 0: + { + break label_1; + } + case 1: + { + break label_3; + } + case 2: + { + break label_1; + } + default: + { + break label_3; + } + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 16) & 0xFF)) != 0) { + break label_4; + } + local5 = (arg2 + -98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 21) != 0) { + break label_4; + } + if (((1835015 >>> local5) & 1) != 0) { + break label_1; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) (local3 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + local4 = 1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(325, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local3 + 80))); + return (local4 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_444(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_444(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_445(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 0); + label_1: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 108) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 10895); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(337, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 24)); + long[] callResult_2 = instance.getMachine().call(331, callArgs_2); + arg0 = ((int) callResult_2[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg0)); + } + + public static long[] call_445(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_445(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_446(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) 0); + label_1: { + label_2: { + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_2; + } + local3 = (local2 - local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local3, -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local2 + ((local3 >> 3) << 3))); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + label_3: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_3; + } + label_4: while (true) { + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + local2 = (local2 + 8); + local3 = (local3 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) 0L); + memory.writeI32((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (int) 0); + label_5: { + local2 = memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_5; + } + local3 = (local2 - local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local3, -1) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local2 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local2 + ((local3 >> 3) << 3))); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local2); + label_6: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_6; + } + label_7: while (true) { + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + local2 = (local2 + 8); + local3 = (local3 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24)); + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_446(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_446(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_447(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg1); + memory.writeLong((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0, (long) 0L); + return arg0; + } + + public static long[] call_447(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_447(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_448(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + memory.writeI32((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + memory.writeI32((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28)); + memory.writeI32((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(449, callArgs_0); + label_1: { + label_2: { + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)) != 0) { + break label_2; + } + label_3: while (true) { + local3 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) + -4); + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + arg1 = (arg1 + -4); + switch(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) { + case 0: + { + break label_12; + } + case 1: + { + break label_11; + } + case 2: + { + break label_10; + } + case 3: + { + break label_9; + } + case 4: + { + break label_8; + } + case 5: + { + break label_6; + } + case 6: + { + break label_7; + } + case 7: + { + break label_5; + } + default: + { + break label_4; + } + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + arg1 = 1; + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local2); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(450, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_1[0])) != 0) { + break label_4; + } + break label_1; + } + label_13: { + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) + -4); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_13; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(449, callArgs_2); + break label_4; + } + arg1 = 1; + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 16)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local2); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + -4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) + -4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) + -8)); + break label_4; + } + label_14: { + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) + -4); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_14; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(449, callArgs_4); + break label_4; + } + arg1 = 1; + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 84)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local2); + callArgs_5[0] = ((long) local3); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + -4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) + -4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) + -8)); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local2 + 184)); + callArgs_6[2] = ((long) local2); + callArgs_6[1] = ((long) 3); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(451, callArgs_6); + break label_4; + } + label_15: { + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) + -4); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_15; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local3); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(449, callArgs_7); + break label_4; + } + arg1 = 1; + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + int ciTableIdx_8 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 88)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local2); + callArgs_8[0] = ((long) local3); + long[] callResult_8 = ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_8[0])) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + -4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) + -4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) + -8)); + break label_4; + } + label_16: { + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) + -4); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_16; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local3); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(449, callArgs_9); + break label_4; + } + arg1 = 1; + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 112)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) local2); + callArgs_10[0] = ((long) local3); + long[] callResult_10 = ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_10[0])) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + -4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) + -4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) + -8)); + break label_4; + } + label_17: { + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) + -4); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) local3); + callArgs_11[0] = ((long) arg0); + instance.getMachine().call(449, callArgs_11); + break label_4; + } + arg1 = 1; + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + int ciTableIdx_12 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 36)); + int ciFuncId_12 = instance.table(0).requiredRef(ciTableIdx_12); + com.dylibso.chicory.runtime.Instance ciRefInstance_12 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_12), instance); + if (!ciRefInstance_12.type(ciRefInstance_12.functionType(ciFuncId_12)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) local2); + callArgs_12[0] = ((long) local3); + long[] callResult_12 = ciRefInstance_12.getMachine().call(ciFuncId_12, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + -4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) + -4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) + -8)); + break label_4; + } + label_18: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local5 = (local4 + -4); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_18; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) local6); + callArgs_13[0] = ((long) arg0); + instance.getMachine().call(449, callArgs_13); + break label_4; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (local4 + -8)); + label_19: { + label_20: { + label_21: { + switch(memory.readInt((int) local2 < 0 ? local2 : local2 + 36)) { + case 0: + { + break label_19; + } + case 1: + { + break label_21; + } + case 2: + { + break label_20; + } + default: + { + break label_4; + } + } + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + label_22: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 188); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (local2 + 192) < 0 ? (local2 + 192) : (local2 + 192) + 0), local3) != 0) { + break label_22; + } + arg1 = 1; + int ciTableIdx_14 = (int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 220)); + int ciFuncId_14 = instance.table(0).requiredRef(ciTableIdx_14); + com.dylibso.chicory.runtime.Instance ciRefInstance_14 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_14), instance); + if (!ciRefInstance_14.type(ciRefInstance_14.functionType(ciFuncId_14)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) local3); + callArgs_14[1] = ((long) local2); + callArgs_14[0] = ((long) local5); + long[] callResult_14 = ciRefInstance_14.getMachine().call(ciFuncId_14, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])) != 0) { + break label_1; + } + long[] callArgs_15 = new long[4]; + callArgs_15[3] = ((long) (local3 + 56)); + callArgs_15[2] = ((long) 0); + callArgs_15[1] = ((long) local2); + callArgs_15[0] = ((long) arg0); + instance.getMachine().call(452, callArgs_15); + break label_4; + } + arg1 = 1; + int ciTableIdx_16 = (int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 228)); + int ciFuncId_16 = instance.table(0).requiredRef(ciTableIdx_16); + com.dylibso.chicory.runtime.Instance ciRefInstance_16 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_16), instance); + if (!ciRefInstance_16.type(ciRefInstance_16.functionType(ciFuncId_16)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) local2); + callArgs_16[0] = ((long) local5); + long[] callResult_16 = ciRefInstance_16.getMachine().call(ciFuncId_16, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_16[0])) != 0) { + break label_4; + } + break label_1; + } + arg1 = 1; + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + int ciTableIdx_17 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 224)); + int ciFuncId_17 = instance.table(0).requiredRef(ciTableIdx_17); + com.dylibso.chicory.runtime.Instance ciRefInstance_17 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_17), instance); + if (!ciRefInstance_17.type(ciRefInstance_17.functionType(ciFuncId_17)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) local2); + callArgs_17[0] = ((long) local3); + long[] callResult_17 = ciRefInstance_17.getMachine().call(ciFuncId_17, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_17[0])) != 0) { + break label_4; + } + break label_1; + } + arg1 = 1; + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + int ciTableIdx_18 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 228)); + int ciFuncId_18 = instance.table(0).requiredRef(ciTableIdx_18); + com.dylibso.chicory.runtime.Instance ciRefInstance_18 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_18), instance); + if (!ciRefInstance_18.type(ciRefInstance_18.functionType(ciFuncId_18)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) local2); + callArgs_18[0] = ((long) local3); + long[] callResult_18 = ciRefInstance_18.getMachine().call(ciFuncId_18, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_18[0])) != 0) { + break label_4; + } + break label_1; + } + label_23: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + local5 = (local4 + -4); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_23; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) local6); + callArgs_19[0] = ((long) arg0); + instance.getMachine().call(449, callArgs_19); + break label_4; + } + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 188); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (local4 + -8)); + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 44) + -4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 44, (int) arg1); + label_24: { + local3 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) (local2 + 192) < 0 ? (local2 + 192) : (local2 + 192) + 0) - local5), 68)) != 0) { + break label_24; + } + arg1 = 1; + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = (local5 + (local3 * 68)); + int ciTableIdx_20 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 220)); + int ciFuncId_20 = instance.table(0).requiredRef(ciTableIdx_20); + com.dylibso.chicory.runtime.Instance ciRefInstance_20 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_20), instance); + if (!ciRefInstance_20.type(ciRefInstance_20.functionType(ciFuncId_20)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_20 = new long[3]; + callArgs_20[2] = ((long) local5); + callArgs_20[1] = ((long) local2); + callArgs_20[0] = ((long) local6); + long[] callResult_20 = ciRefInstance_20.getMachine().call(ciFuncId_20, callArgs_20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_20[0])) != 0) { + break label_1; + } + long[] callArgs_21 = new long[4]; + callArgs_21[3] = ((long) (local5 + 56)); + callArgs_21[2] = ((long) local3); + callArgs_21[1] = ((long) local2); + callArgs_21[0] = ((long) arg0); + instance.getMachine().call(452, callArgs_21); + break label_4; + } + arg1 = 1; + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + int ciTableIdx_22 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 228)); + int ciFuncId_22 = instance.table(0).requiredRef(ciTableIdx_22); + com.dylibso.chicory.runtime.Instance ciRefInstance_22 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_22), instance); + if (!ciRefInstance_22.type(ciRefInstance_22.functionType(ciFuncId_22)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) local2); + callArgs_22[0] = ((long) local3); + long[] callResult_22 = ciRefInstance_22.getMachine().call(ciFuncId_22, callArgs_22); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_22[0])) != 0) { + break label_1; + } + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + arg1 = 0; + } + return arg1; + } + + public static long[] call_448(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_448(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_449(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + local3 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, local3) != 0) { + break label_4; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local2 + 4)); + break label_3; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = ((local2 - local4) >> 2); + local6 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 1073741824) != 0) { + break label_2; + } + local7 = 0; + label_5: { + local3 = (local3 - local4); + local8 = (local3 >>> 1); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6) : 1073741823); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 1073741824) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local6 << 2)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local7 = ((int) callResult_0[0]); + } + local3 = (local7 + (local5 << 2)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + local7 = (local7 + (local6 << 2)); + local6 = (local3 + 4); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_6; + } + label_7: while (true) { + local3 = (local3 + -4); + local2 = (local2 + -4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_1); + } + label_8: { + local2 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local3 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, local3) != 0) { + break label_8; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local2 + 4)); + return; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local5 = ((local2 - local4) >> 2); + local7 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 1073741824) != 0) { + break label_2; + } + label_9: { + label_10: { + local3 = (local3 - local4); + local6 = (local3 >>> 1); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local7) != 0 ? local6 : local7) : 1073741823); + if (local7 != 0) { + break label_10; + } + local6 = 0; + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 1073741824) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local7 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local6 = ((int) callResult_2[0]); + } + local3 = (local6 + (local5 << 2)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + arg1 = (local6 + (local7 << 2)); + local7 = (local3 + 4); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_11; + } + label_12: while (true) { + local3 = (local3 + -4); + local2 = (local2 + -4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local3); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_13; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_449(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_449(arg0, arg1, memory, instance); + return null; + } + + public static int func_450(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[4]; + iL[0] = arg0; + iL[1] = arg1; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + int _d1 = func_450__h1(iL, memory, instance); + if (_d1 == 1) + break label_7; + if (_d1 == 2) + break label_6; + if (_d1 == 3) + break label_5; + if (_d1 == 4) + break label_4; + if (_d1 == 5) + break label_8; + if (_d1 == 6) + break label_10; + if (_d1 == 7) + break label_9; + if (_d1 == 8) + break label_3; + if (_d1 == 9) + break label_2; + if (_d1 == 10) + break label_1; + } + iL[2] = 1; + iL[3] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_59 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 32)); + int ciFuncId_59 = instance.table(0).requiredRef(ciTableIdx_59); + com.dylibso.chicory.runtime.Instance ciRefInstance_59 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_59), instance); + if (!ciRefInstance_59.type(ciRefInstance_59.functionType(ciFuncId_59)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_59 = new long[2]; + callArgs_59[1] = ((long) iL[1]); + callArgs_59[0] = ((long) iL[3]); + long[] callResult_59 = ciRefInstance_59.getMachine().call(ciFuncId_59, callArgs_59); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_59[0])) != 0) { + break label_1; + } + long[] callArgs_60 = new long[4]; + callArgs_60[3] = ((long) (iL[1] + 152)); + callArgs_60[2] = ((long) iL[1]); + callArgs_60[1] = ((long) 6); + callArgs_60[0] = ((long) iL[0]); + instance.getMachine().call(451, callArgs_60); + break label_2; + } + iL[2] = 1; + iL[3] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_61 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 216)); + int ciFuncId_61 = instance.table(0).requiredRef(ciTableIdx_61); + com.dylibso.chicory.runtime.Instance ciRefInstance_61 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_61), instance); + if (!ciRefInstance_61.type(ciRefInstance_61.functionType(ciFuncId_61)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_61 = new long[2]; + callArgs_61[1] = ((long) iL[1]); + callArgs_61[0] = ((long) iL[3]); + long[] callResult_61 = ciRefInstance_61.getMachine().call(ciFuncId_61, callArgs_61); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_61[0])) != 0) { + break label_1; + } + long[] callArgs_62 = new long[4]; + callArgs_62[3] = ((long) (iL[1] + 156)); + callArgs_62[2] = ((long) iL[1]); + callArgs_62[1] = ((long) 5); + callArgs_62[0] = ((long) iL[0]); + instance.getMachine().call(451, callArgs_62); + break label_2; + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_63 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 208)); + int ciFuncId_63 = instance.table(0).requiredRef(ciTableIdx_63); + com.dylibso.chicory.runtime.Instance ciRefInstance_63 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_63), instance); + if (!ciRefInstance_63.type(ciRefInstance_63.functionType(ciFuncId_63)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_63 = new long[2]; + callArgs_63[1] = ((long) iL[1]); + callArgs_63[0] = ((long) iL[0]); + long[] callResult_63 = ciRefInstance_63.getMachine().call(ciFuncId_63, callArgs_63); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_63[0])) != 0) { + break label_2; + } + break label_1; + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_64 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 272)); + int ciFuncId_64 = instance.table(0).requiredRef(ciTableIdx_64); + com.dylibso.chicory.runtime.Instance ciRefInstance_64 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_64), instance); + if (!ciRefInstance_64.type(ciRefInstance_64.functionType(ciFuncId_64)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_64 = new long[2]; + callArgs_64[1] = ((long) iL[1]); + callArgs_64[0] = ((long) iL[0]); + long[] callResult_64 = ciRefInstance_64.getMachine().call(ciFuncId_64, callArgs_64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_64[0])) != 0) { + break label_2; + } + break label_1; + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_65 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 276)); + int ciFuncId_65 = instance.table(0).requiredRef(ciTableIdx_65); + com.dylibso.chicory.runtime.Instance ciRefInstance_65 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_65), instance); + if (!ciRefInstance_65.type(ciRefInstance_65.functionType(ciFuncId_65)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_65 = new long[2]; + callArgs_65[1] = ((long) iL[1]); + callArgs_65[0] = ((long) iL[0]); + long[] callResult_65 = ciRefInstance_65.getMachine().call(ciFuncId_65, callArgs_65); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_65[0])) != 0) { + break label_2; + } + break label_1; + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_66 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 280)); + int ciFuncId_66 = instance.table(0).requiredRef(ciTableIdx_66); + com.dylibso.chicory.runtime.Instance ciRefInstance_66 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_66), instance); + if (!ciRefInstance_66.type(ciRefInstance_66.functionType(ciFuncId_66)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_66 = new long[2]; + callArgs_66[1] = ((long) iL[1]); + callArgs_66[0] = ((long) iL[0]); + long[] callResult_66 = ciRefInstance_66.getMachine().call(ciFuncId_66, callArgs_66); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_66[0])) != 0) { + break label_2; + } + break label_1; + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_67 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 284)); + int ciFuncId_67 = instance.table(0).requiredRef(ciTableIdx_67); + com.dylibso.chicory.runtime.Instance ciRefInstance_67 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_67), instance); + if (!ciRefInstance_67.type(ciRefInstance_67.functionType(ciFuncId_67)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_67 = new long[2]; + callArgs_67[1] = ((long) iL[1]); + callArgs_67[0] = ((long) iL[0]); + long[] callResult_67 = ciRefInstance_67.getMachine().call(ciFuncId_67, callArgs_67); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_67[0])) != 0) { + break label_2; + } + break label_1; + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_68 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 288)); + int ciFuncId_68 = instance.table(0).requiredRef(ciTableIdx_68); + com.dylibso.chicory.runtime.Instance ciRefInstance_68 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_68), instance); + if (!ciRefInstance_68.type(ciRefInstance_68.functionType(ciFuncId_68)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_68 = new long[2]; + callArgs_68[1] = ((long) iL[1]); + callArgs_68[0] = ((long) iL[0]); + long[] callResult_68 = ciRefInstance_68.getMachine().call(ciFuncId_68, callArgs_68); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_68[0])) != 0) { + break label_2; + } + break label_1; + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_69 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 212)); + int ciFuncId_69 = instance.table(0).requiredRef(ciTableIdx_69); + com.dylibso.chicory.runtime.Instance ciRefInstance_69 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_69), instance); + if (!ciRefInstance_69.type(ciRefInstance_69.functionType(ciFuncId_69)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_69 = new long[2]; + callArgs_69[1] = ((long) iL[1]); + callArgs_69[0] = ((long) iL[0]); + long[] callResult_69 = ciRefInstance_69.getMachine().call(ciFuncId_69, callArgs_69); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_69[0])) != 0) { + break label_1; + } + } + iL[2] = 0; + } + return iL[2]; + } + + public static long[] call_450(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_450(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_451(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + local5 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_4; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local4 + 4)); + break label_3; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local7 = ((local4 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + label_5: { + label_6: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_6; + } + local9 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local8 << 2)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local9 = ((int) callResult_0[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg1); + arg1 = (local9 + (local8 << 2)); + local8 = (local5 + 4); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_7; + } + label_8: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_1); + } + label_9: { + label_10: { + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_10; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local4 + 4)); + break label_9; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local9 = ((local4 - local6) >> 2); + arg1 = (local9 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_2; + } + label_11: { + label_12: { + local5 = (local5 - local6); + local8 = (local5 >>> 1); + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, arg1) != 0 ? local8 : arg1) : 1073741823); + if (arg1 != 0) { + break label_12; + } + local8 = 0; + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg1 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local8 = ((int) callResult_2[0]); + } + local5 = (local8 + (local9 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg2); + arg1 = (local8 + (arg1 << 2)); + arg2 = (local5 + 4); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_13; + } + label_14: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_9; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + label_15: { + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local5 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_15; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (local4 + 8)); + return; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local9 = ((local4 - local6) >> 3); + arg2 = (local9 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 536870912) != 0) { + break label_2; + } + label_16: { + label_17: { + local5 = (local5 - local6); + local8 = (local5 >>> 2); + arg2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, arg2) != 0 ? local8 : arg2) : 536870911); + if (arg2 != 0) { + break label_17; + } + local8 = 0; + break label_16; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 536870912) != 0) { + break label_1; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) (arg2 << 3)); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local8 = ((int) callResult_4[0]); + } + local5 = (local8 + (local9 << 3)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg3); + arg3 = (local8 + (arg2 << 3)); + arg1 = (local5 + 8); + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_18; + } + label_19: while (true) { + local5 = (local5 + -8); + local4 = (local4 + -8); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_19; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 28, (int) local5); + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_20; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_5); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_451(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_451(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_452(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + local5 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_4; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local4 + 4)); + break label_3; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local7 = ((local4 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + label_5: { + label_6: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_6; + } + local9 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local8 << 2)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local9 = ((int) callResult_0[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 7); + local8 = (local9 + (local8 << 2)); + local9 = (local5 + 4); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_7; + } + label_8: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_1); + } + label_9: { + label_10: { + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_10; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local4 + 4)); + break label_9; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local7 = ((local4 - local6) >> 2); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_2; + } + label_11: { + label_12: { + local5 = (local5 - local6); + local9 = (local5 >>> 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 1073741823); + if (local8 != 0) { + break label_12; + } + local9 = 0; + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 1073741824) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local8 << 2)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local9 = ((int) callResult_2[0]); + } + local5 = (local9 + (local7 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg1); + arg1 = (local9 + (local8 << 2)); + local8 = (local5 + 4); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_13; + } + label_14: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_9; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + label_15: { + label_16: { + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + local5 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_16; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) (local4 + 8)); + break label_15; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local7 = ((local4 - local6) >> 3); + local8 = (local7 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 536870912) != 0) { + break label_2; + } + label_17: { + label_18: { + local5 = (local5 - local6); + local9 = (local5 >>> 2); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local8) != 0 ? local9 : local8) : 536870911); + if (local8 != 0) { + break label_18; + } + local9 = 0; + break label_17; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 536870912) != 0) { + break label_1; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) (local8 << 3)); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local9 = ((int) callResult_4[0]); + } + local5 = (local9 + (local7 << 3)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg3); + arg3 = (local9 + (local8 << 3)); + arg1 = (local5 + 8); + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_19; + } + label_20: while (true) { + local5 = (local5 + -8); + local4 = (local4 + -8); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 28, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_15; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_5); + } + label_21: { + local4 = memory.readInt((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0); + local5 = memory.readInt((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_21; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 44, (int) (local4 + 4)); + return; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + local8 = ((local4 - local6) >> 2); + arg3 = (local8 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, 1073741824) != 0) { + break label_2; + } + label_22: { + label_23: { + local5 = (local5 - local6); + arg1 = (local5 >>> 1); + arg3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, arg3) != 0 ? arg1 : arg3) : 1073741823); + if (arg3 != 0) { + break label_23; + } + arg1 = 0; + break label_22; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, 1073741824) != 0) { + break label_1; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) (arg3 << 2)); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + arg1 = ((int) callResult_6[0]); + } + local5 = (arg1 + (local8 << 2)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg2); + arg3 = (arg1 + (arg3 << 2)); + arg1 = (local5 + 4); + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_24; + } + label_25: while (true) { + local5 = (local5 + -4); + local4 = (local4 + -4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_25; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 48, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 44, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 40, (int) local5); + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_26; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_7); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_452(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_452(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_453(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (arg1 != 0) { + break label_1; + } + return 0; + } + label_2: { + label_3: while (true) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(448, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_2; + } + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + return 0; + } + return 1; + } + + public static long[] call_453(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_453(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_454(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 148); + if (arg1 != 0) { + break label_1; + } + return 0; + } + label_2: { + label_3: while (true) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(448, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_2; + } + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + return 0; + } + return 1; + } + + public static long[] call_454(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_454(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_455(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[15]; + long[] lL = new long[1]; + iL[0] = arg0; + iL[2] = (((int) instance.global(0).getValue()) - 592); + instance.global(0).setValue(((long) iL[2])); + label_1: { + int _d0 = func_455__h0(iL, lL, memory, instance); + } + iL[8] = (iL[0] + 12); + long[] callArgs_70 = new long[2]; + callArgs_70[1] = ((long) ((memory.readInt((int) (iL[3] + 176) < 0 ? (iL[3] + 176) : (iL[3] + 176) + 0) - memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 172)) >> 2)); + callArgs_70[0] = ((long) iL[8]); + instance.getMachine().call(362, callArgs_70); + label_63: { + iL[13] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_63; + } + iL[14] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 48); + label_64: while (true) { + label_65: { + if (memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 32) != 0) { + break label_65; + } + iL[9] = (iL[13] + 196); + iL[4] = iL[9]; + label_66: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) (iL[13] + 192) < 0 ? (iL[13] + 192) : (iL[13] + 192) + 0)) != 0) { + break label_66; + } + iL[4] = (memory.readInt((int) (iL[13] + 188) < 0 ? (iL[13] + 188) : (iL[13] + 188) + 0) + 12); + } + iL[10] = (iL[13] + 184); + long[] callArgs_71 = new long[3]; + callArgs_71[2] = ((long) iL[14]); + callArgs_71[1] = ((long) iL[9]); + callArgs_71[0] = ((long) iL[8]); + long[] callResult_71 = instance.getMachine().call(370, callArgs_71); + iL[6] = ((int) callResult_71[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[6]))); + label_67: { + iL[6] = memory.readInt((int) (iL[13] + 152) < 0 ? (iL[13] + 152) : (iL[13] + 152) + 0); + iL[11] = memory.readInt((int) (iL[13] + 156) < 0 ? (iL[13] + 156) : (iL[13] + 156) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[11], iL[6]) != 0) { + break label_67; + } + label_68: while (true) { + iL[7] = memory.readInt((int) (iL[6] + 8) < 0 ? (iL[6] + 8) : (iL[6] + 8) + 0); + lL[0] = memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 16, (long) lL[0]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 160, (long) lL[0]); + long[] callArgs_72 = new long[4]; + callArgs_72[3] = ((long) (iL[2] + 16)); + callArgs_72[2] = ((long) iL[7]); + callArgs_72[1] = ((long) iL[9]); + callArgs_72[0] = ((long) iL[8]); + long[] callResult_72 = instance.getMachine().call(372, callArgs_72); + iL[7] = ((int) callResult_72[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + iL[6] = (iL[6] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[6]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_68; + } + break; + } + } + long[] callArgs_73 = new long[2]; + callArgs_73[1] = ((long) iL[0]); + callArgs_73[0] = ((long) (iL[2] + 360)); + long[] callResult_73 = instance.getMachine().call(447, callArgs_73); + long[] callArgs_74 = new long[2]; + callArgs_74[1] = ((long) iL[10]); + callArgs_74[0] = ((long) ((int) callResult_73[0])); + long[] callResult_74 = instance.getMachine().call(453, callArgs_74); + iL[6] = ((int) callResult_74[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[6]))); + long[] callArgs_75 = new long[2]; + callArgs_75[1] = ((long) iL[4]); + callArgs_75[0] = ((long) iL[8]); + long[] callResult_75 = instance.getMachine().call(371, callArgs_75); + iL[6] = ((int) callResult_75[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[6]))); + label_69: { + iL[6] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 400); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_69; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 404, (int) iL[6]); + long[] callArgs_76 = new long[1]; + callArgs_76[0] = ((long) iL[6]); + instance.getMachine().call(1777, callArgs_76); + } + label_70: { + iL[6] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 388); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_70; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 392, (int) iL[6]); + long[] callArgs_77 = new long[1]; + callArgs_77[0] = ((long) iL[6]); + instance.getMachine().call(1777, callArgs_77); + } + label_71: { + iL[6] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 376); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_71; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 380, (int) iL[6]); + long[] callArgs_78 = new long[1]; + callArgs_78[0] = ((long) iL[6]); + instance.getMachine().call(1777, callArgs_78); + } + label_72: { + iL[6] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 364); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_72; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 368, (int) iL[6]); + long[] callArgs_79 = new long[1]; + callArgs_79[0] = ((long) iL[6]); + instance.getMachine().call(1777, callArgs_79); + } + iL[14] = (iL[14] + 1); + } + iL[13] = memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 4); + if (iL[13] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_64; + } + break; + } + iL[6] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_63; + } + label_73: while (true) { + label_74: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 32)) != 0) { + break label_74; + } + iL[11] = (iL[6] + 12); + iL[13] = (iL[6] + 52); + long[] callArgs_80 = new long[2]; + callArgs_80[1] = ((long) iL[13]); + callArgs_80[0] = ((long) (iL[2] + 120)); + long[] callResult_80 = instance.getMachine().call(159, callArgs_80); + iL[7] = ((int) callResult_80[0]); + long[] callArgs_81 = new long[4]; + callArgs_81[3] = ((long) memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 36)); + callArgs_81[2] = ((long) iL[7]); + callArgs_81[1] = ((long) iL[11]); + callArgs_81[0] = ((long) iL[8]); + long[] callResult_81 = instance.getMachine().call(363, callArgs_81); + iL[9] = ((int) callResult_81[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[9]))); + long[] callArgs_82 = new long[1]; + callArgs_82[0] = ((long) iL[7]); + long[] callResult_82 = instance.getMachine().call(162, callArgs_82); + if (memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 36) != 0) { + break label_74; + } + lL[0] = 4294967295L; + label_75: { + long[] callArgs_83 = new long[2]; + callArgs_83[1] = ((long) iL[13]); + callArgs_83[0] = ((long) iL[3]); + long[] callResult_83 = instance.getMachine().call(124, callArgs_83); + iL[7] = ((int) callResult_83[0]); + iL[9] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 160); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[7], ((memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 164) - iL[9]) >> 2)) != 0) { + break label_75; + } + lL[0] = (((int) memory.read((int) (memory.readInt((int) (iL[9] + (iL[7] << 2)) < 0 ? (iL[9] + (iL[7] << 2)) : (iL[9] + (iL[7] << 2)) + 0) + 34) < 0 ? (memory.readInt((int) (iL[9] + (iL[7] << 2)) < 0 ? (iL[9] + (iL[7] << 2)) : (iL[9] + (iL[7] << 2)) + 0) + 34) : (memory.readInt((int) (iL[9] + (iL[7] << 2)) < 0 ? (iL[9] + (iL[7] << 2)) : (iL[9] + (iL[7] << 2)) + 0) + 34) + 0) & 0xFF) != 0 ? 4294967294L : 4294967295L); + } + lL[0] = (lL[0] | -4294967296L); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 8, (long) lL[0]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 112, (long) lL[0]); + long[] callArgs_84 = new long[3]; + callArgs_84[2] = ((long) (iL[2] + 8)); + callArgs_84[1] = ((long) iL[11]); + callArgs_84[0] = ((long) iL[8]); + long[] callResult_84 = instance.getMachine().call(368, callArgs_84); + iL[7] = ((int) callResult_84[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + long[] callArgs_85 = new long[2]; + callArgs_85[1] = ((long) iL[0]); + callArgs_85[0] = ((long) (iL[2] + 360)); + long[] callResult_85 = instance.getMachine().call(447, callArgs_85); + long[] callArgs_86 = new long[2]; + callArgs_86[1] = ((long) (iL[6] + 88)); + callArgs_86[0] = ((long) ((int) callResult_85[0])); + long[] callResult_86 = instance.getMachine().call(453, callArgs_86); + iL[7] = ((int) callResult_86[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + long[] callArgs_87 = new long[1]; + callArgs_87[0] = ((long) iL[8]); + long[] callResult_87 = instance.getMachine().call(369, callArgs_87); + iL[7] = ((int) callResult_87[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + label_76: { + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 400); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[7]) != 0) { + break label_76; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 404, (int) iL[7]); + long[] callArgs_88 = new long[1]; + callArgs_88[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_88); + } + label_77: { + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 388); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[7]) != 0) { + break label_77; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 392, (int) iL[7]); + long[] callArgs_89 = new long[1]; + callArgs_89[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_89); + } + label_78: { + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 376); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[7]) != 0) { + break label_78; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 380, (int) iL[7]); + long[] callArgs_90 = new long[1]; + callArgs_90[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_90); + } + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 364); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[7]) != 0) { + break label_74; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 368, (int) iL[7]); + long[] callArgs_91 = new long[1]; + callArgs_91[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_91); + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_73; + } + break; + } + } + long[] callArgs_92 = new long[1]; + callArgs_92[0] = ((long) iL[8]); + long[] callResult_92 = instance.getMachine().call(364, callArgs_92); + iL[6] = ((int) callResult_92[0]); + iL[6] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[6])); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) iL[6]); + instance.global(0).setValue(((long) (iL[2] + 592))); + return iL[6]; + } + + public static long[] call_455(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_455(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_456(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 272); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 276) < 0 ? (arg0 + 276) : (arg0 + 276) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + local2 = (local3 + -36); + label_3: while (true) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local2); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + local3 = ((int) callResult_0[0]); + local2 = (local2 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 272); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 276, (int) local1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) (arg0 + 264) < 0 ? (arg0 + 264) : (arg0 + 264) + 0)); + callArgs_2[0] = ((long) (arg0 + 260)); + instance.getMachine().call(34, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) memory.readInt((int) (arg0 + 252) < 0 ? (arg0 + 252) : (arg0 + 252) + 0)); + callArgs_3[0] = ((long) (arg0 + 248)); + instance.getMachine().call(534, callArgs_3); + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 236); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_4; + } + memory.writeI32((int) (arg0 + 240) < 0 ? (arg0 + 240) : (arg0 + 240) + 0, (int) local2); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_4); + } + label_5: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 212); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_5; + } + memory.writeI32((int) (arg0 + 216) < 0 ? (arg0 + 216) : (arg0 + 216) + 0, (int) local2); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_5); + } + label_6: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 200); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_6; + } + local2 = local1; + label_7: { + local3 = memory.readInt((int) (arg0 + 204) < 0 ? (arg0 + 204) : (arg0 + 204) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_7; + } + local2 = (local3 + -12); + label_8: while (true) { + label_9: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_9; + } + memory.writeI32((int) (local2 + 4) < 0 ? (local2 + 4) : (local2 + 4) + 0, (int) local3); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_6); + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local2); + local2 = (local2 + -12); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 200); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 204, (int) local1); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_7); + } + label_10: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 188); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_10; + } + memory.writeI32((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0, (int) local2); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_8); + } + label_11: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 176); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_11; + } + memory.writeI32((int) (arg0 + 180) < 0 ? (arg0 + 180) : (arg0 + 180) + 0, (int) local2); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_9); + } + label_12: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 164); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_12; + } + memory.writeI32((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0, (int) local2); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_10); + } + label_13: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_13; + } + local2 = local1; + label_14: { + local3 = memory.readInt((int) (arg0 + 156) < 0 ? (arg0 + 156) : (arg0 + 156) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_14; + } + local2 = (local3 + -28); + label_15: while (true) { + label_16: { + local3 = memory.readInt((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_16; + } + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) local3); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_11); + } + label_17: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + memory.writeI32((int) (local2 + 4) < 0 ? (local2 + 4) : (local2 + 4) + 0, (int) local3); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_12); + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local2); + local2 = (local2 + -28); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_15; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 152); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 156, (int) local1); + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_13); + } + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) memory.readInt((int) (arg0 + 144) < 0 ? (arg0 + 144) : (arg0 + 144) + 0)); + callArgs_14[0] = ((long) (arg0 + 140)); + instance.getMachine().call(535, callArgs_14); + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) memory.readInt((int) (arg0 + 132) < 0 ? (arg0 + 132) : (arg0 + 132) + 0)); + callArgs_15[0] = ((long) (arg0 + 128)); + instance.getMachine().call(536, callArgs_15); + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) memory.readInt((int) (arg0 + 120) < 0 ? (arg0 + 120) : (arg0 + 120) + 0)); + callArgs_16[0] = ((long) (arg0 + 116)); + instance.getMachine().call(537, callArgs_16); + label_18: { + local1 = memory.readInt((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_18; + } + local2 = local1; + label_19: { + local3 = memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_19; + } + local2 = (local3 + -32); + label_20: while (true) { + label_21: { + local3 = memory.readInt((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_21; + } + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) local3); + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_17); + } + label_22: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_22; + } + memory.writeI32((int) (local2 + 4) < 0 ? (local2 + 4) : (local2 + 4) + 0, (int) local3); + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_18); + } + local3 = (local2 + -4); + local2 = (local2 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 52); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 56, (int) local1); + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_19); + } + label_23: { + local2 = memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_23; + } + memory.writeI32((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0, (int) local2); + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_20); + } + label_24: { + local2 = memory.readInt((int) memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0) < 0 ? memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0) : memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_24; + } + int ciTableIdx_21 = (int) (local2); + int ciFuncId_21 = instance.table(0).requiredRef(ciTableIdx_21); + com.dylibso.chicory.runtime.Instance ciRefInstance_21 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_21), instance); + if (!ciRefInstance_21.type(ciRefInstance_21.functionType(ciFuncId_21)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + ciRefInstance_21.getMachine().call(ciFuncId_21, callArgs_21); + } + return arg0; + } + + public static long[] call_456(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_456(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_457(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + local3 = (((int) instance.global(0).getValue()) - 304); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 42204); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local3 + 12)); + long[] callResult_0 = instance.getMachine().call(335, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 300, (int) 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 296, (int) arg0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + long[] callResult_1 = instance.getMachine().call(455, callArgs_1); + arg2 = ((int) callResult_1[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 42204); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(456, callArgs_2); + instance.global(0).setValue(((long) (local3 + 304))); + return arg2; + } + + public static long[] call_457(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_457(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_458(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 42204); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(456, callArgs_0); + return arg0; + } + + public static long[] call_458(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_458(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_459(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local4), 36); + local6 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 119304648) != 0) { + break label_4; + } + label_5: { + label_6: { + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local4), 36); + local7 = (local4 << 1); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, local6) != 0 ? local7 : local6) : 119304647); + if (local7 != 0) { + break label_6; + } + local4 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 119304648) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local7 * 36)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + } + local8 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local8); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local6 = ((int) callResult_1[0]); + arg3 = (local4 + (local5 * 36)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 4, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (arg3 + 12) < 0 ? (arg3 + 12) : (arg3 + 12) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) (arg3 + 20) < 0 ? (arg3 + 20) : (arg3 + 20) + 0, (int) memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 2147483632) != 0) { + break label_4; + } + local7 = (local7 * 36); + arg2 = (arg3 + 24); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 10) != 0) { + break label_8; + } + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 35, (byte) (local6)); + break label_7; + } + local9 = ((local6 | 15) + 1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local9); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + local5 = (local4 + (local5 * 36)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) (local9 | -2147483648)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg1); + memory.writeI32((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (int) local6); + arg2 = arg1; + } + arg1 = (local4 + local7); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local6); + callArgs_3[1] = ((long) local8); + callArgs_3[0] = ((long) arg2); + long[] callResult_3 = instance.getMachine().call(1891, callArgs_3); + memory.writeByte((int) (((int) callResult_3[0]) + local6) < 0 ? (((int) callResult_3[0]) + local6) : (((int) callResult_3[0]) + local6) + 0, (byte) (0)); + local8 = (arg3 + 36); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local4) != 0) { + break label_2; + } + label_9: while (true) { + arg2 = (arg3 + -36); + local6 = (local4 + -36); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (long) memory.readLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + arg3 = (arg3 + -12); + local4 = (local4 + -12); + local7 = (local4 + 8); + memory.writeI32((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 0); + local4 = local6; + arg3 = arg2; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_1; + } + local6 = (local6 + -12); + label_10: while (true) { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local6 + 11) < 0 ? (local6 + 11) : (local6 + 11) + 0), -1) != 0) { + break label_11; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + instance.getMachine().call(1777, callArgs_4); + } + arg2 = (local6 + -24); + local6 = (local6 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg3); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_12; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_7); + } + return; + } + + public static long[] call_459(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_459(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_460(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 42204); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(456, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_460(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_460(arg0, memory, instance); + return null; + } + + public static int func_461(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(380, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_461(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_461(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_462(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = (arg1 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF)) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) memory.readInt((int) (arg1 + 76) < 0 ? (arg1 + 76) : (arg1 + 76) + 0)); + break label_1; + } + local4 = memory.readInt((int) (arg0 + 296) < 0 ? (arg0 + 296) : (arg0 + 296) + 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0), memory.readInt((int) (arg1 + 88) < 0 ? (arg1 + 88) : (arg1 + 88) + 0)) != 0) { + break label_3; + } + label_4: { + local5 = memory.readInt((int) (arg1 + 100) < 0 ? (arg1 + 100) : (arg1 + 100) + 0); + local6 = memory.readInt((int) (arg1 + 104) < 0 ? (arg1 + 104) : (arg1 + 104) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local5) != 0) { + break label_4; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) -64L); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, (local6 - local5)) != 0) { + break label_3; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(135, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local3); + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) (arg1 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(381, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_462(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_462(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_463(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 164)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(399, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_463(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_463(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_464(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(382, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_464(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_464(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_465(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(383, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_465(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_465(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_466(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 12); + local4 = (arg1 + 12); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(384, callArgs_0); + local5 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5))); + label_1: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local6 = memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local5) != 0) { + break label_1; + } + label_2: while (true) { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local7); + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + long[] callResult_2 = instance.getMachine().call(385, callArgs_2); + local8 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local8))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local7); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + local5 = (local5 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (arg1 + 48)); + callArgs_4[0] = ((long) local2); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local5 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local5); + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) local3); + long[] callResult_5 = instance.getMachine().call(385, callArgs_5); + local7 = ((int) callResult_5[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7))); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local5); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local4); + callArgs_7[0] = ((long) local3); + long[] callResult_7 = instance.getMachine().call(386, callArgs_7); + local5 = ((int) callResult_7[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5))); + instance.global(0).setValue(((long) (local2 + 80))); + return 0; + } + + public static long[] call_466(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_466(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_467(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 12); + local4 = (arg0 + 12); + label_1: { + label_2: { + local5 = (arg1 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) memory.readInt((int) (arg1 + 76) < 0 ? (arg1 + 76) : (arg1 + 76) + 0)); + break label_1; + } + local6 = memory.readInt((int) (arg0 + 296) < 0 ? (arg0 + 296) : (arg0 + 296) + 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0), memory.readInt((int) (arg1 + 88) < 0 ? (arg1 + 88) : (arg1 + 88) + 0)) != 0) { + break label_3; + } + label_4: { + local7 = memory.readInt((int) (arg1 + 100) < 0 ? (arg1 + 100) : (arg1 + 100) + 0); + local8 = memory.readInt((int) (arg1 + 104) < 0 ? (arg1 + 104) : (arg1 + 104) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local7) != 0) { + break label_4; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) -64L); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, (local8 - local7)) != 0) { + break label_3; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(135, callArgs_0); + local6 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local6); + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 24)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 8)); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(441, callArgs_1); + local6 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6))); + label_5: { + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 184); + local8 = memory.readInt((int) (arg1 + 188) < 0 ? (arg1 + 188) : (arg1 + 188) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local6) != 0) { + break label_5; + } + label_6: while (true) { + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local6); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(442, callArgs_2); + local7 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7))); + local6 = (local6 + 96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) != 0) { + break label_8; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) memory.readInt((int) (arg1 + 76) < 0 ? (arg1 + 76) : (arg1 + 76) + 0)); + break label_7; + } + local6 = memory.readInt((int) (arg0 + 296) < 0 ? (arg0 + 296) : (arg0 + 296) + 0); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0), memory.readInt((int) (arg1 + 88) < 0 ? (arg1 + 88) : (arg1 + 88) + 0)) != 0) { + break label_9; + } + label_10: { + local7 = memory.readInt((int) (arg1 + 100) < 0 ? (arg1 + 100) : (arg1 + 100) + 0); + local8 = memory.readInt((int) (arg1 + 104) < 0 ? (arg1 + 104) : (arg1 + 104) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local7) != 0) { + break label_10; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) -64L); + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, (local8 - local7)) != 0) { + break label_9; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + break label_7; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(135, callArgs_3); + local6 = ((int) callResult_3[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local2); + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) local4); + long[] callResult_4 = instance.getMachine().call(443, callArgs_4); + local6 = ((int) callResult_4[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6))); + instance.global(0).setValue(((long) (local2 + 32))); + return 0; + } + + public static long[] call_467(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_467(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_468(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 164)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(399, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_468(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_468(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_469(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(387, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_469(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_469(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_470(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 36) & 0xFF)) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 40)); + callArgs_0[0] = ((long) (local2 + 40)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + break label_1; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 36)); + callArgs_1[0] = ((long) memory.readInt((int) (arg0 + 296) < 0 ? (arg0 + 296) : (arg0 + 296) + 0)); + long[] callResult_1 = instance.getMachine().call(135, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) ((int) callResult_1[0])); + callArgs_2[0] = ((long) (local2 + 40)); + long[] callResult_2 = instance.getMachine().call(155, callArgs_2); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (arg1 + 140)); + callArgs_3[0] = ((long) local2); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) arg1); + callArgs_4[2] = ((long) (local2 + 40)); + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) (arg0 + 12)); + long[] callResult_4 = instance.getMachine().call(388, callArgs_4); + local3 = ((int) callResult_4[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) (local2 + 40)); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + instance.global(0).setValue(((long) (local2 + 80))); + return 0; + } + + public static long[] call_470(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_470(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_471(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + local3 = 1; + local4 = (arg1 + 12); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local2 + 44)); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(389, callArgs_0); + local5 = ((int) callResult_0[0]); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) local5); + label_1: { + if (local5 != 0) { + break label_1; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 44)); + callArgs_1[0] = ((long) (local2 + 8)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + arg0 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg0); + callArgs_2[0] = ((long) (arg1 + 36)); + long[] callResult_2 = instance.getMachine().call(158, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + local3 = 0; + } + instance.global(0).setValue(((long) (local2 + 48))); + return local3; + } + + public static long[] call_471(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_471(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_472(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_472(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_472(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_473(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(391, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_473(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_473(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_474(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(392, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_474(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_474(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_475(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(393, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_475(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_475(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_476(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(396, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_476(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_476(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_477(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(400, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_477(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_477(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_478(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(401, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_478(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_478(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_479(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = (arg1 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF)) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) memory.readInt((int) (arg1 + 76) < 0 ? (arg1 + 76) : (arg1 + 76) + 0)); + break label_1; + } + local4 = memory.readInt((int) (arg0 + 296) < 0 ? (arg0 + 296) : (arg0 + 296) + 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0), memory.readInt((int) (arg1 + 88) < 0 ? (arg1 + 88) : (arg1 + 88) + 0)) != 0) { + break label_3; + } + label_4: { + local5 = memory.readInt((int) (arg1 + 100) < 0 ? (arg1 + 100) : (arg1 + 100) + 0); + local6 = memory.readInt((int) (arg1 + 104) < 0 ? (arg1 + 104) : (arg1 + 104) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local5) != 0) { + break label_4; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) -64L); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, (local6 - local5)) != 0) { + break label_3; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(135, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local3); + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) (arg1 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(402, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_479(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_479(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_480(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) (arg1 + 192) < 0 ? (arg1 + 192) : (arg1 + 192) + 0)) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 164)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(398, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + } + return 0; + } + + public static long[] call_480(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_480(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_481(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + (memory.readInt((int) (arg1 + 192) < 0 ? (arg1 + 192) : (arg1 + 192) + 0) != 0 ? 196 : 164))); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(399, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_481(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_481(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_482(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(403, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_482(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_482(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_483(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(406, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_483(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_483(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_484(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(407, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_484(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_484(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_485(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(408, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_485(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_485(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_486(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = (arg1 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF)) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) memory.readInt((int) (arg1 + 76) < 0 ? (arg1 + 76) : (arg1 + 76) + 0)); + break label_1; + } + local4 = memory.readInt((int) (arg0 + 296) < 0 ? (arg0 + 296) : (arg0 + 296) + 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0), memory.readInt((int) (arg1 + 88) < 0 ? (arg1 + 88) : (arg1 + 88) + 0)) != 0) { + break label_3; + } + label_4: { + local5 = memory.readInt((int) (arg1 + 100) < 0 ? (arg1 + 100) : (arg1 + 100) + 0); + local6 = memory.readInt((int) (arg1 + 104) < 0 ? (arg1 + 104) : (arg1 + 104) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local5) != 0) { + break label_4; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) -64L); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, (local6 - local5)) != 0) { + break label_3; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(135, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local3); + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) (arg1 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(409, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_486(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_486(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_487(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 164)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(399, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_487(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_487(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_488(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 40)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 72)); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + _snap_0 = arg1; + arg1 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) arg1); + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) (_snap_0 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(410, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + instance.global(0).setValue(((long) (local2 + 80))); + return 0; + } + + public static long[] call_488(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_488(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_489(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(394, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_489(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_489(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_490(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(411, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_490(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_490(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_491(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(412, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_491(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_491(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_492(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 72)); + callArgs_0[0] = ((long) (local2 + 40)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 36)); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + _snap_0 = arg1; + arg1 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) arg1); + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) (_snap_0 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(413, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + instance.global(0).setValue(((long) (local2 + 80))); + return 0; + } + + public static long[] call_492(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_492(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_493(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(414, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_493(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_493(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_494(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 40)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 72)); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + _snap_0 = arg1; + arg1 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) arg1); + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) (_snap_0 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(430, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + instance.global(0).setValue(((long) (local2 + 80))); + return 0; + } + + public static long[] call_494(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_494(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_495(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(397, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_495(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_495(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_496(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 40)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 72)); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + _snap_0 = arg1; + arg1 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) arg1); + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) (_snap_0 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(434, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + instance.global(0).setValue(((long) (local2 + 80))); + return 0; + } + + public static long[] call_496(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_496(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_497(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(432, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_497(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_497(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_498(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(435, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_498(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_498(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_499(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(433, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_499(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_499(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_500(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(436, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_500(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_500(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_501(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(431, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_501(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_501(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_502(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(416, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_502(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_502(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_503(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 36); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(419, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_503(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_503(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_504(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(418, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_504(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_504(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_505(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(415, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_505(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_505(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_506(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(423, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_506(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_506(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_507(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(421, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_507(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_507(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_508(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 36) & 0xFF)) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 40)); + callArgs_0[0] = ((long) (local2 + 40)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + break label_1; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 36)); + callArgs_1[0] = ((long) memory.readInt((int) (arg0 + 296) < 0 ? (arg0 + 296) : (arg0 + 296) + 0)); + long[] callResult_1 = instance.getMachine().call(135, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) ((int) callResult_1[0])); + callArgs_2[0] = ((long) (local2 + 40)); + long[] callResult_2 = instance.getMachine().call(155, callArgs_2); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (arg1 + 140)); + callArgs_3[0] = ((long) local2); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) arg1); + callArgs_4[2] = ((long) (local2 + 40)); + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) (arg0 + 12)); + long[] callResult_4 = instance.getMachine().call(422, callArgs_4); + local3 = ((int) callResult_4[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) (local2 + 40)); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + instance.global(0).setValue(((long) (local2 + 80))); + return 0; + } + + public static long[] call_508(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_508(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_509(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + _snap_0 = arg1; + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg1); + callArgs_0[2] = ((long) ((memory.readInt((int) (_snap_0 + 40) < 0 ? (_snap_0 + 40) : (_snap_0 + 40) + 0) - arg1) >> 3)); + callArgs_0[1] = ((long) (_snap_0 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(424, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_509(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_509(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_510(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(429, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_510(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_510(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_511(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(444, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_511(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_511(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_512(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(445, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_512(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_512(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_513(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = (arg1 + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF)) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) memory.readInt((int) (arg1 + 80) < 0 ? (arg1 + 80) : (arg1 + 80) + 0)); + break label_1; + } + local4 = memory.readInt((int) (arg0 + 296) < 0 ? (arg0 + 296) : (arg0 + 296) + 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg1 + 96) < 0 ? (arg1 + 96) : (arg1 + 96) + 0), memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0)) != 0) { + break label_3; + } + label_4: { + local5 = memory.readInt((int) (arg1 + 104) < 0 ? (arg1 + 104) : (arg1 + 104) + 0); + local6 = memory.readInt((int) (arg1 + 108) < 0 ? (arg1 + 108) : (arg1 + 108) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local5) != 0) { + break label_4; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) -64L); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, (local6 - local5)) != 0) { + break label_3; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(135, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) -1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local3); + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) (arg1 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(440, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_513(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_513(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_514(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg2 + 20)); + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) (arg2 + 40) < 0 ? (arg2 + 40) : (arg2 + 40) + 0)) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, memory.readInt((int) (arg2 + 44) < 0 ? (arg2 + 44) : (arg2 + 44) + 0)))); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(390, callArgs_1); + arg2 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg2))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local3 + 48))); + return 0; + } + + public static long[] call_514(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_514(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_515(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 200)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(395, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_515(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_515(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_516(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 168)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(399, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_516(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_516(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_517(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(438, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_517(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_517(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_518(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(439, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_518(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_518(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_519(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + _snap_0 = arg1; + arg1 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (_snap_0 + 12)); + callArgs_1[0] = ((long) (arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(420, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local3))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_519(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_519(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_520(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(379, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_520(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_520(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_521(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(373, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_521(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_521(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_522(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(375, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_522(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_522(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_523(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(374, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_523(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_523(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_524(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(378, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_524(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_524(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_525(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(377, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_525(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_525(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_526(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(376, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_526(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_526(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_527(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(437, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_527(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_527(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_528(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 40); + callArgs_0[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(425, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + return 0; + } + + public static long[] call_528(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_528(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_529(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[7]; + callArgs_2[6] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 96); + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(426, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_529(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_529(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_530(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[7]; + callArgs_2[6] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 96); + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(427, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_530(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_530(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_531(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) memory.readLong((int) (arg1 + 48) < 0 ? (arg1 + 48) : (arg1 + 48) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 40)); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local2); + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) (arg0 + 12)); + long[] callResult_0 = instance.getMachine().call(428, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_531(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_531(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_532(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(404, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_532(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_532(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_533(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 80); + callArgs_1[0] = ((long) (arg1 + 72)); + long[] callResult_1 = instance.getMachine().call(193, callArgs_1); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88); + callArgs_2[4] = callResult_1[0]; + callArgs_2[3] = ((long) local3); + callArgs_2[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 72)); + callArgs_2[1] = ((long) (arg1 + 12)); + callArgs_2[0] = ((long) (arg0 + 12)); + long[] callResult_2 = instance.getMachine().call(405, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1))); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + + public static long[] call_533(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_533(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_534(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(534, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(534, callArgs_1); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 27), -1) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + instance.getMachine().call(1777, callArgs_2); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + + public static long[] call_534(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_534(arg0, arg1, memory, instance); + return null; + } + + public static void func_535(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(535, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(535, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_2); + } + return; + } + + public static long[] call_535(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_535(arg0, arg1, memory, instance); + return null; + } + + public static void func_536(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(536, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(536, callArgs_1); + label_2: { + arg0 = memory.readInt((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (int) arg0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + + public static long[] call_536(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_536(arg0, arg1, memory, instance); + return null; + } + + public static void func_537(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(537, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(537, callArgs_1); + label_2: { + arg0 = memory.readInt((int) (arg1 + 32) < 0 ? (arg1 + 32) : (arg1 + 32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + memory.writeI32((int) (arg1 + 36) < 0 ? (arg1 + 36) : (arg1 + 36) + 0, (int) arg0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + } + label_3: { + arg0 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + memory.writeI32((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (int) arg0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_3); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_4); + } + return; + } + + public static long[] call_537(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_537(arg0, arg1, memory, instance); + return null; + } + + public static int func_538(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = 17915; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg0, 140) != 0) { + break label_1; + } + local1 = memory.readInt((int) ((arg0 << 2) + 42592) < 0 ? ((arg0 << 2) + 42592) : ((arg0 << 2) + 42592) + 0); + } + return local1; + } + + public static long[] call_538(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_538(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_539(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + return arg0; + } + + public static long[] call_539(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_539(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_540(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 24, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + return arg0; + } + + public static long[] call_540(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_540(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_541(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 24, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + return arg0; + } + + public static long[] call_541(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_541(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_542(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + return arg0; + } + + public static long[] call_542(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_542(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_543(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg2); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 24, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeI32((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0, (int) memory.readInt((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + return arg0; + } + + public static long[] call_543(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_543(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_544(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 56) != 0) { + break label_3; + } + local3 = memory.readInt((int) ((local3 << 2) + 42592) < 0 ? ((local3 << 2) + 42592) : ((local3 << 2) + 42592) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + arg1 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 2147483632) != 0) { + break label_1; + } + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 10) != 0) { + break label_5; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (arg1)); + break label_4; + } + local4 = ((arg1 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local4 | -2147483648)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + arg0 = local5; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + arg1) < 0 ? (((int) callResult_2[0]) + arg1) : (((int) callResult_2[0]) + arg1) + 0, (byte) (0)); + break label_2; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local3 + -57), 2) != 0) { + break label_6; + } + local3 = memory.readInt((int) (arg1 + 32) < 0 ? (arg1 + 32) : (arg1 + 32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + arg1 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_8; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (local3)); + break label_7; + } + local4 = ((local3 | 15) + 1); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local5 = ((int) callResult_3[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local4 | -2147483648)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + arg0 = local5; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local3); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1891, callArgs_4); + memory.writeByte((int) (((int) callResult_4[0]) + local3) < 0 ? (((int) callResult_4[0]) + local3) : (((int) callResult_4[0]) + local3) + 0, (byte) (0)); + break label_2; + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local3 + -60), 70) != 0) { + break label_9; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (arg1 + 24)); + callArgs_5[0] = ((long) local2); + instance.getMachine().call(192, callArgs_5); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + long[] callResult_6 = instance.getMachine().call(1897, callArgs_6); + arg1 = ((int) callResult_6[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 2147483632) != 0) { + break label_1; + } + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 10) != 0) { + break label_11; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (arg1)); + break label_10; + } + local4 = ((arg1 | 15) + 1); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + local5 = ((int) callResult_7[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local4 | -2147483648)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + arg0 = local5; + } + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) arg1); + callArgs_8[1] = ((long) local3); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1891, callArgs_8); + memory.writeByte((int) (((int) callResult_8[0]) + arg1) < 0 ? (((int) callResult_8[0]) + arg1) : (((int) callResult_8[0]) + arg1) + 0, (byte) (0)); + break label_2; + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local3 + -131), 5) != 0) { + break label_12; + } + local3 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + label_13: { + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_14; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (local3)); + break label_13; + } + local4 = ((local3 | 15) + 1); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + local5 = ((int) callResult_9[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local4 | -2147483648)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + arg0 = local5; + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) local3); + callArgs_10[1] = ((long) arg1); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1891, callArgs_10); + memory.writeByte((int) (((int) callResult_10[0]) + local3) < 0 ? (((int) callResult_10[0]) + local3) : (((int) callResult_10[0]) + local3) + 0, (byte) (0)); + break label_2; + } + arg1 = (arg1 + 24); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local3 + -138), 2) != 0) { + break label_15; + } + local3 = 26480; + label_16: { + label_17: { + label_18: { + label_19: { + label_20: { + label_21: { + switch((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 34)) { + case 0: + { + break label_18; + } + case 1: + { + break label_19; + } + case 2: + { + break label_17; + } + case 3: + { + break label_17; + } + case 4: + { + break label_17; + } + case 5: + { + break label_17; + } + case 6: + { + break label_17; + } + case 7: + { + break label_17; + } + case 8: + { + break label_17; + } + case 9: + { + break label_17; + } + case 10: + { + break label_17; + } + case 11: + { + break label_20; + } + case 12: + { + break label_17; + } + case 13: + { + break label_17; + } + case 14: + { + break label_17; + } + case 15: + { + break label_17; + } + case 16: + { + break label_17; + } + case 17: + { + break label_21; + } + case 18: + { + break label_16; + } + default: + { + break label_17; + } + } + } + local3 = 12289; + break label_16; + } + local3 = 12251; + break label_16; + } + local3 = 7364; + break label_16; + } + local3 = 1310; + break label_16; + } + local3 = 27489; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local3); + long[] callResult_11 = instance.getMachine().call(1897, callArgs_11); + arg1 = ((int) callResult_11[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 2147483632) != 0) { + break label_1; + } + label_22: { + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 10) != 0) { + break label_23; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (arg1)); + break label_22; + } + local4 = ((arg1 | 15) + 1); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local4); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + local5 = ((int) callResult_12[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local4 | -2147483648)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + arg0 = local5; + } + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) arg1); + callArgs_13[1] = ((long) local3); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(1890, callArgs_13); + memory.writeByte((int) (((int) callResult_13[0]) + arg1) < 0 ? (((int) callResult_13[0]) + arg1) : (((int) callResult_13[0]) + arg1) + 0, (byte) (0)); + break label_2; + } + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) arg1); + callArgs_14[0] = ((long) arg0); + instance.getMachine().call(38, callArgs_14); + } + instance.global(0).setValue(((long) (local2 + 64))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_544(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_544(arg0, arg1, memory, instance); + return null; + } + + public static void func_545(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local3 + 24)); + instance.getMachine().call(544, callArgs_0); + label_1: { + label_2: { + arg1 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 35) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 28) : arg1), arg2) != 0) { + break label_2; + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) (local3 + 40)); + callArgs_1[3] = ((long) (arg2 + -3)); + callArgs_1[2] = ((long) 0); + callArgs_1[1] = ((long) (local3 + 24)); + callArgs_1[0] = ((long) (local3 + 8)); + long[] callResult_1 = instance.getMachine().call(1653, callArgs_1); + arg1 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 29207); + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(1662, callArgs_2); + arg2 = ((int) callResult_2[0]); + local4 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + arg2 = (arg2 + 8); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) local4); + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) local5); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_3); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 35), -1) != 0) { + break label_1; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 24)); + instance.getMachine().call(1777, callArgs_4); + break label_1; + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 24)); + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) memory.readInt((int) ((local3 + 24) + 8) < 0 ? ((local3 + 24) + 8) : ((local3 + 24) + 8) + 0)); + } + instance.global(0).setValue(((long) (local3 + 48))); + return; + } + + public static long[] call_545(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_545(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_546(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + label_1: { + label_2: { + local2 = (arg0 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 10) != 0) { + break label_2; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((arg0 + -97), 5) != 0) { + break label_3; + } + local2 = (arg0 + -87); + break label_2; + } + local2 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((arg0 + -65), 5) != 0) { + break label_1; + } + local2 = (arg0 + -55); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local2); + local2 = 0; + } + return local2; + } + + public static long[] call_546(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_546(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_547(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + int local6 = 0; + local3 = 1; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg0) != 0) { + break label_1; + } + label_2: { + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(48, ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_4; + } + local4 = (arg0 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, arg1) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(120, ((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_4; + } + label_5: { + local4 = (arg0 + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local4) != 0) { + break label_5; + } + return 1; + } + local5 = 0L; + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, arg1) != 0) { + break label_6; + } + arg0 = local4; + break label_2; + } + local6 = ((arg1 - arg0) + -2); + local5 = 0L; + label_7: while (true) { + label_8: { + arg0 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, arg0) != 0) { + break label_8; + } + label_9: { + local3 = (arg0 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 10) != 0) { + break label_9; + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((arg0 + -97), 5) != 0) { + break label_10; + } + local3 = (arg0 + -87); + break label_9; + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((arg0 + -65), 5) != 0) { + break label_11; + } + return 1; + } + local3 = (arg0 + -55); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local5, 1152921504606846975L) != 0) { + break label_12; + } + return 1; + } + local5 = ((local5 << 4L) + com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3)); + } + local4 = (local4 + 1); + local6 = (local6 + -1); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break label_3; + } + } + local5 = 0L; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, arg1) != 0) { + break label_2; + } + local4 = (arg1 - arg0); + local5 = 0L; + label_13: while (true) { + label_14: { + local6 = (int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local6) != 0) { + break label_14; + } + local3 = 1; + local6 = (local6 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 9) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local5, 1844674407370955161L) != 0) { + break label_1; + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(1844674407370955161L, local5) != 0) { + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 5) != 0) { + break label_1; + } + } + local5 = ((local5 * 10L) + com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local6)); + } + arg0 = (arg0 + 1); + local4 = (local4 + -1); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break; + } + } + arg0 = arg1; + } + local3 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg0) != 0) { + break label_1; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) local5); + local3 = 0; + } + return local3; + } + + public static long[] call_547(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_547(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_548(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + label_4: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + switch((local5 + -43)) { + case 0: + { + break label_3; + } + case 1: + { + break label_4; + } + case 2: + { + break label_3; + } + default: + { + break label_4; + } + } + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) 0L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local4 + 8)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(547, callArgs_0); + arg3 = ((int) callResult_0[0]); + break label_2; + } + label_5: { + if (arg3 != 0) { + break label_5; + } + arg3 = 1; + break label_1; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) 0L); + arg3 = 1; + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local4 + 8)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (arg0 + 1)); + long[] callResult_1 = instance.getMachine().call(547, callArgs_1); + arg0 = ((int) callResult_1[0]); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(45, local5) != 0) { + break label_6; + } + local6 = memory.readLong((int) local4 < 0 ? local4 : local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local6, -9223372036854775808L) != 0) { + break label_1; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) (0L - local6)); + } + arg3 = arg0; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 8)); + } + instance.global(0).setValue(((long) (local4 + 16))); + return arg3; + } + + public static long[] call_548(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_548(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_549(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + switch((local5 + -43)) { + case 0: + { + break label_5; + } + case 1: + { + break label_4; + } + case 2: + { + break label_5; + } + default: + { + break label_4; + } + } + } + local6 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local4 + 8)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 1)); + long[] callResult_0 = instance.getMachine().call(547, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + local7 = memory.readLong((int) local4 < 0 ? local4 : local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(45, local5) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local7, 128L) != 0) { + break label_1; + } + local7 = (256L - local7); + break label_2; + } + local6 = 1; + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local4 + 8)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(547, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + local7 = memory.readLong((int) local4 < 0 ? local4 : local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local7, 255L) != 0) { + break label_2; + } + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local7, 255L) != 0) { + break label_1; + } + } + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 0, (byte) (int) (local7)); + local6 = 0; + } + instance.global(0).setValue(((long) (local4 + 16))); + return local6; + } + + public static long[] call_549(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_549(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_550(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + switch((local5 + -43)) { + case 0: + { + break label_5; + } + case 1: + { + break label_4; + } + case 2: + { + break label_5; + } + default: + { + break label_4; + } + } + } + local6 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local4 + 8)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 1)); + long[] callResult_0 = instance.getMachine().call(547, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + local7 = memory.readLong((int) local4 < 0 ? local4 : local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(45, local5) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local7, 32768L) != 0) { + break label_1; + } + local7 = (65536L - local7); + break label_2; + } + local6 = 1; + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local4 + 8)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(547, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + local7 = memory.readLong((int) local4 < 0 ? local4 : local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local7, 65535L) != 0) { + break label_2; + } + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local7, 65535L) != 0) { + break label_1; + } + } + memory.writeShort((int) arg2 < 0 ? arg2 : arg2 + 0, (short) (int) (local7)); + local6 = 0; + } + instance.global(0).setValue(((long) (local4 + 16))); + return local6; + } + + public static long[] call_550(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_550(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_551(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + switch((local5 + -43)) { + case 0: + { + break label_5; + } + case 1: + { + break label_4; + } + case 2: + { + break label_5; + } + default: + { + break label_4; + } + } + } + local6 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local4 + 8)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 1)); + long[] callResult_0 = instance.getMachine().call(547, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + local7 = memory.readLong((int) local4 < 0 ? local4 : local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(45, local5) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local7, 2147483648L) != 0) { + break label_1; + } + local7 = (4294967296L - local7); + break label_2; + } + local6 = 1; + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local4 + 8)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(547, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + local7 = memory.readLong((int) local4 < 0 ? local4 : local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local7, 4294967295L) != 0) { + break label_2; + } + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local7, 4294967295L) != 0) { + break label_1; + } + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local7); + local6 = 0; + } + instance.global(0).setValue(((long) (local4 + 16))); + return local6; + } + + public static long[] call_551(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_551(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_552(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_1 = 0; + int _snap_0 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + switch(arg0) { + case 0: + { + break label_5; + } + case 1: + { + break label_5; + } + case 2: + { + break label_9; + } + case 3: + { + break label_8; + } + case 4: + { + break label_7; + } + default: + { + break label_6; + } + } + } + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, local4); + arg1 = (arg1 + (local5 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(43, local4))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U((arg1 + 2), arg2) != 0) { + break label_2; + } + arg1 = (arg1 + 4); + local6 = 0; + local7 = 0; + local8 = 0; + local9 = 0; + label_10: { + label_11: { + label_12: while (true) { + label_13: { + label_14: { + arg0 = ((int) memory.read((int) (arg1 + -2) < 0 ? (arg1 + -2) : (arg1 + -2) + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(46, arg0) != 0) { + break label_14; + } + local6 = 1; + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, arg0) != 0) { + break label_13; + } + label_15: { + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0); + arg0 = (local10 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, 10) != 0) { + break label_15; + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local10 + -97), 5) != 0) { + break label_16; + } + arg0 = (local10 + -87); + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local10 + -65), 5) != 0) { + break label_11; + } + arg0 = (local10 + -55); + } + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 16777215) != 0) { + break label_17; + } + local7 = ((local6 & 1) != 0 ? (local7 + -4) : local7); + local8 = (arg0 + (local8 << 4)); + break label_13; + } + local7 = ((local6 & 1) != 0 ? local7 : (local7 + 4)); + local9 = ((local9 & 255) != 0 ? local9 : (arg0 != 0 ? 1 : local9)); + } + arg0 = (arg1 + -1); + arg1 = (arg1 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break; + } + arg1 = 0; + if (local8 != 0) { + break label_10; + } + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_2; + } + local10 = 0; + label_18: { + arg0 = (arg1 + -1); + _snap_0 = arg0; + arg0 = (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 255); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(43, arg0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, arg0); + arg1 = (local5 != 0 ? arg1 : (local6 != 0 ? arg1 : _snap_0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, arg2) != 0) { + break label_18; + } + local6 = (local5 != 0 ? (0 - local7) : (local6 != 0 ? local7 : 0)); + arg2 = (arg2 - arg1); + local10 = 0; + label_19: while (true) { + label_20: { + arg0 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, arg0) != 0) { + break label_20; + } + local10 = (((local10 * 10) + arg0) + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((local10 + local6), 127) != 0) { + break label_18; + } + } + arg1 = (arg1 + 1); + arg2 = (arg2 + -1); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_19; + } + break; + } + } + arg1 = (local5 != 0 ? (0 - local10) : local10); + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ(local8); + arg1 = ((local7 - arg2) + arg1); + arg0 = (arg1 + 32); + label_21: { + arg1 = (arg1 + 31); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg1, -127) != 0) { + break label_21; + } + label_22: { + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 8388608) != 0) { + break label_23; + } + local7 = (local8 >>> (9 - arg2)); + local9 = (local9 | com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (local8 & ((-1 << (8 - arg2)) ^ -1)))); + break label_22; + } + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(9, arg2) != 0) { + break label_24; + } + local7 = local8; + break label_22; + } + local7 = (local8 << (arg2 + -9)); + } + label_25: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, -150) != 0) { + break label_25; + } + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-127, arg1) != 0) { + break label_26; + } + arg1 = (-127 - arg0); + arg2 = (1 << arg1); + _snap_1 = arg1; + arg1 = (-126 - arg0); + local7 = ((((((local7 >>> arg1) & 1) != 0 ? arg2 : (((local9 | com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (local7 & ((-1 << _snap_1) ^ -1)))) & 255) != 0 ? arg2 : 0)) + local7) >>> arg1) & 8388607); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_25; + } + arg1 = (local7 | (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, local4) << 31)); + break label_1; + } + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, local4) << 31); + break label_1; + } + label_27: { + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 16777216) != 0) { + break label_28; + } + local7 = (1 << (7 - arg2)); + arg2 = (8 - arg2); + local8 = ((((local9 & 255) != 0 ? local7 : (((local8 >>> arg2) & 1) != 0 ? local7 : 0)) + local8) >>> arg2); + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 16777215) != 0 ? arg0 : arg1); + break label_27; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(8, arg2) != 0) { + break label_27; + } + local8 = (local8 << (arg2 + -8)); + } + arg0 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg1, 127) != 0) { + break label_4; + } + arg1 = (((local8 & 8388607) | (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, local4) << 31)) | ((arg1 << 23) + 1065353216)); + break label_1; + } + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)) != 0 ? -8388608 : 2139095040)); + return 0; + } + label_29: { + arg0 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, arg0); + arg1 = (arg1 + (local10 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(43, arg0))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, (arg1 + 3)) != 0) { + break label_29; + } + local8 = 4194304; + break label_3; + } + arg0 = 1; + arg1 = (arg1 + 6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, arg2) != 0) { + break label_4; + } + local8 = 0; + label_30: while (true) { + label_31: { + arg0 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, arg0) != 0) { + break label_31; + } + label_32: { + local7 = (arg0 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 10) != 0) { + break label_32; + } + label_33: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((arg0 + -97), 5) != 0) { + break label_33; + } + local7 = (arg0 + -87); + break label_32; + } + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((arg0 + -65), 5) != 0) { + break label_34; + } + return 1; + } + local7 = (arg0 + -55); + } + local8 = (local7 + (local8 << 4)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local8, 8388607) != 0) { + break label_31; + } + return 1; + } + arg1 = (arg1 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_30; + } + break; + } + if (local8 != 0) { + break label_3; + } + return 1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg3); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) arg1); + long[] callResult_1 = instance.getMachine().call(553, callArgs_1); + arg0 = ((int) callResult_1[0]); + } + return arg0; + } + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) (local8 | (local10 != 0 ? -8388608 : 2139095040))); + return 0; + } + arg1 = (local5 << 31); + } + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg1); + return 0; + } + + public static long[] call_552(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_552(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_553(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + float local9 = 0.0f; + local3 = (((int) instance.global(0).getValue()) - 16); + local4 = local3; + instance.global(0).setValue(((long) local3)); + local5 = (arg1 - arg0); + local6 = (local3 - ((local5 + 16) & -16)); + instance.global(0).setValue(((long) local6)); + local3 = local6; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, arg1) != 0) { + break label_1; + } + local7 = ((arg0 ^ -1) + arg1); + label_2: { + label_3: { + local5 = (local5 & 3); + if (local5 != 0) { + break label_3; + } + local3 = local6; + break label_2; + } + local3 = local6; + label_4: while (true) { + label_5: { + local8 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local8) != 0) { + break label_5; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local8)); + local3 = (local3 + 1); + } + arg0 = (arg0 + 1); + local5 = (local5 + -1); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 3) != 0) { + break label_1; + } + label_6: while (true) { + label_7: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local5) != 0) { + break label_7; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local5)); + local3 = (local3 + 1); + } + label_8: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local5) != 0) { + break label_8; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local5)); + local3 = (local3 + 1); + } + label_9: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local5) != 0) { + break label_9; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local5)); + local3 = (local3 + 1); + } + label_10: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local5) != 0) { + break label_10; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local5)); + local3 = (local3 + 1); + } + arg0 = (arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (0)); + arg0 = 1; + label_11: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 12)); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1886, callArgs_0); + local9 = com.dylibso.chicory.wasm.types.Value.longToFloat(callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.F32_EQ(local9, Float.NEGATIVE_INFINITY) != 0) { + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.F32_EQ(local9, Float.POSITIVE_INFINITY) != 0) { + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, memory.readInt((int) local4 < 0 ? local4 : local4 + 12)) != 0) { + break label_11; + } + memory.writeF32((int) arg2 < 0 ? arg2 : arg2 + 0, (float) local9); + arg0 = 0; + } + instance.global(0).setValue(((long) (local4 + 16))); + return arg0; + } + + public static long[] call_553(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_553(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_554(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long _snap_1 = 0; + int _snap_0 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + int local8 = 0; + int local9 = 0; + int local10 = 0; + long local11 = 0L; + long local12 = 0L; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + switch(arg0) { + case 0: + { + break label_5; + } + case 1: + { + break label_5; + } + case 2: + { + break label_9; + } + case 3: + { + break label_8; + } + case 4: + { + break label_7; + } + default: + { + break label_6; + } + } + } + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, local4); + arg1 = (arg1 + (local5 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(43, local4))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U((arg1 + 2), arg2) != 0) { + break label_2; + } + arg1 = (arg1 + 4); + local6 = 0; + local7 = 0L; + local8 = 0; + local9 = 0; + label_10: { + label_11: { + label_12: while (true) { + label_13: { + label_14: { + arg0 = ((int) memory.read((int) (arg1 + -2) < 0 ? (arg1 + -2) : (arg1 + -2) + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(46, arg0) != 0) { + break label_14; + } + local6 = 1; + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, arg0) != 0) { + break label_13; + } + label_15: { + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0); + arg0 = (local10 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, 10) != 0) { + break label_15; + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local10 + -97), 5) != 0) { + break label_16; + } + arg0 = (local10 + -87); + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local10 + -65), 5) != 0) { + break label_11; + } + arg0 = (local10 + -55); + } + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((int) com.dylibso.chicory.runtime.OpcodeImpl.I64_CLZ(local7), 11) != 0) { + break label_17; + } + local8 = ((local6 & 1) != 0 ? (local8 + -4) : local8); + local7 = ((local7 << 4L) + com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg0)); + break label_13; + } + local8 = ((local6 & 1) != 0 ? local8 : (local8 + 4)); + local9 = ((local9 & 255) != 0 ? local9 : (arg0 != 0 ? 1 : local9)); + } + arg0 = (arg1 + -1); + arg1 = (arg1 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break; + } + arg1 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(0L, local7) != 0) { + break label_10; + } + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(local7) != 0) { + break label_2; + } + local10 = 0; + label_18: { + arg0 = (arg1 + -1); + _snap_0 = arg0; + arg0 = (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 255); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(43, arg0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, arg0); + arg1 = (local5 != 0 ? arg1 : (local6 != 0 ? arg1 : _snap_0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, arg2) != 0) { + break label_18; + } + local6 = (local5 != 0 ? (0 - local8) : (local6 != 0 ? local8 : 0)); + arg2 = (arg2 - arg1); + local10 = 0; + label_19: while (true) { + label_20: { + arg0 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, arg0) != 0) { + break label_20; + } + local10 = (((local10 * 10) + arg0) + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((local10 + local6), 1023) != 0) { + break label_18; + } + } + arg1 = (arg1 + 1); + arg2 = (arg2 + -1); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_19; + } + break; + } + } + arg1 = (local5 != 0 ? (0 - local10) : local10); + } + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I64_CLZ(local7); + arg2 = (int) local11; + arg1 = ((local8 - arg2) + arg1); + arg0 = (arg1 + 64); + label_21: { + arg1 = (arg1 + 63); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg1, -1023) != 0) { + break label_21; + } + label_22: { + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 11) != 0) { + break label_23; + } + local12 = (local7 >>> ((12L - local11) & 4294967295L)); + local9 = (local9 | com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(0L, (local7 & ((-1L << ((11L - local11) & 4294967295L)) ^ -1L)))); + break label_22; + } + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(12, arg2) != 0) { + break label_24; + } + local12 = local7; + break label_22; + } + local12 = (local7 << ((local11 + 4294967284L) & 4294967295L)); + } + label_25: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, -1075) != 0) { + break label_25; + } + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1023, arg1) != 0) { + break label_26; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((-1023 - arg0)); + local11 = (1L << local7); + _snap_1 = local7; + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((-1022 - arg0)); + local12 = ((((((int) (local12 >>> local7) & 1) != 0 ? local11 : (((local9 | com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(0L, (local12 & ((-1L << _snap_1) ^ -1L)))) & 255) != 0 ? local11 : 0L)) + local12) >>> local7) & 4503599627370495L); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(local12) != 0) { + break label_25; + } + local7 = (local12 | (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, local4)) << 63L)); + break label_1; + } + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, local4)) << 63L); + break label_1; + } + label_27: { + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 10) != 0) { + break label_28; + } + local12 = (1L << ((10L - local11) & 4294967295L)); + local11 = ((11L - local11) & 4294967295L); + local7 = ((((local9 & 255) != 0 ? local12 : (((int) (local7 >>> local11) & 1) != 0 ? local12 : 0L)) + local7) >>> local11); + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local7, 9007199254740991L) != 0 ? arg0 : arg1); + break label_27; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(11, arg2) != 0) { + break label_27; + } + local7 = (local7 << ((local11 + 4294967285L) & 4294967295L)); + } + arg0 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg1, 1023) != 0) { + break label_4; + } + local7 = (((local7 & 4503599627370495L) | (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, local4)) << 63L)) | (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((arg1 + 1023)) << 52L)); + break label_1; + } + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)) != 0 ? -4503599627370496L : 9218868437227405312L)); + return 0; + } + label_29: { + arg0 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, arg0); + arg1 = (arg1 + (local10 | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(43, arg0))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, (arg1 + 3)) != 0) { + break label_29; + } + local7 = 2251799813685248L; + break label_3; + } + arg0 = 1; + arg1 = (arg1 + 6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, arg2) != 0) { + break label_4; + } + local7 = 0L; + label_30: while (true) { + label_31: { + arg0 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, arg0) != 0) { + break label_31; + } + label_32: { + local8 = (arg0 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 10) != 0) { + break label_32; + } + label_33: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((arg0 + -97), 5) != 0) { + break label_33; + } + local8 = (arg0 + -87); + break label_32; + } + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((arg0 + -65), 5) != 0) { + break label_34; + } + return 1; + } + local8 = (arg0 + -55); + } + local7 = ((local7 << 4L) + com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local8)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local7, 4503599627370495L) != 0) { + break label_31; + } + return 1; + } + arg1 = (arg1 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_30; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(local7)) != 0) { + break label_3; + } + return 1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg3); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) arg1); + long[] callResult_1 = instance.getMachine().call(555, callArgs_1); + arg0 = ((int) callResult_1[0]); + } + return arg0; + } + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) (local7 | (local10 != 0 ? -4503599627370496L : 9218868437227405312L))); + return 0; + } + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local5) << 63L); + } + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) local7); + return 0; + } + + public static long[] call_554(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_554(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_555(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + double local9 = 0.0; + local3 = (((int) instance.global(0).getValue()) - 16); + local4 = local3; + instance.global(0).setValue(((long) local3)); + local5 = (arg1 - arg0); + local6 = (local3 - ((local5 + 16) & -16)); + instance.global(0).setValue(((long) local6)); + local3 = local6; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, arg1) != 0) { + break label_1; + } + local7 = ((arg0 ^ -1) + arg1); + label_2: { + label_3: { + local5 = (local5 & 3); + if (local5 != 0) { + break label_3; + } + local3 = local6; + break label_2; + } + local3 = local6; + label_4: while (true) { + label_5: { + local8 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local8) != 0) { + break label_5; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local8)); + local3 = (local3 + 1); + } + arg0 = (arg0 + 1); + local5 = (local5 + -1); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 3) != 0) { + break label_1; + } + label_6: while (true) { + label_7: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local5) != 0) { + break label_7; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local5)); + local3 = (local3 + 1); + } + label_8: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local5) != 0) { + break label_8; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local5)); + local3 = (local3 + 1); + } + label_9: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local5) != 0) { + break label_9; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local5)); + local3 = (local3 + 1); + } + label_10: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, local5) != 0) { + break label_10; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (local5)); + local3 = (local3 + 1); + } + arg0 = (arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (0)); + arg0 = 1; + label_11: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local4 + 12)); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1887, callArgs_0); + local9 = com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_EQ(local9, Double.NEGATIVE_INFINITY) != 0) { + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_EQ(local9, Double.POSITIVE_INFINITY) != 0) { + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, memory.readInt((int) local4 < 0 ? local4 : local4 + 12)) != 0) { + break label_11; + } + memory.writeF64((int) arg2 < 0 ? arg2 : arg2 + 0, (double) local9); + arg0 = 0; + } + instance.global(0).setValue(((long) (local4 + 16))); + return arg0; + } + + public static long[] call_555(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_555(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_556(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long local4 = 0L; + long local5 = 0L; + int local6 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 12); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) ((int) callResult_0[0])); + long[] callResult_1 = instance.getMachine().call(185, callArgs_1); + arg1 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 44); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg1); + label_1: { + local4 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = (local4 >>> 32L); + arg1 = (int) local5; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 2147483632) != 0) { + break label_1; + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 10) != 0) { + break label_3; + } + arg0 = (arg2 + 4); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 15, (byte) (int) (local5)); + break label_2; + } + local6 = ((arg1 | 15) + 1); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg0 = ((int) callResult_3[0]); + memory.writeI32((int) (arg2 + 12) < 0 ? (arg2 + 12) : (arg2 + 12) + 0, (int) (local6 | -2147483648)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) arg0); + memory.writeI32((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (int) arg1); + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg1); + callArgs_4[1] = ((long) (int) local4); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1891, callArgs_4); + memory.writeByte((int) (((int) callResult_4[0]) + arg1) < 0 ? (((int) callResult_4[0]) + arg1) : (((int) callResult_4[0]) + arg1) + 0, (byte) (0)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 16, (int) 1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 40, (int) arg3); + arg0 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 20, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 36, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 32, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 28, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 24, (int) (arg1 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4))); + return arg2; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_556(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_556(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_557(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[13]; + iL[0] = arg0; + iL[1] = arg1; + iL[3] = (((int) instance.global(0).getValue()) - 336); + instance.global(0).setValue(((long) iL[3])); + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 32, (int) iL[4]); + label_1: { + label_2: { + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[4], iL[5]) != 0) { + break label_2; + } + iL[6] = (iL[1] + 4); + iL[7] = (iL[1] + 28); + label_3: while (true) { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + int _d0 = func_557__h0(iL, memory, instance); + if (_d0 == 1) + break label_6; + if (_d0 == 2) + break label_5; + if (_d0 == 3) + break label_1; + if (_d0 == 4) + break label_8; + if (_d0 == 5) + break label_7; + if (_d0 == 6) + break label_4; + if (_d0 == 7) + break label_9; + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[4]); + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) 59); + callArgs_16[1] = ((long) iL[1]); + callArgs_16[0] = ((long) iL[0]); + instance.getMachine().call(561, callArgs_16); + break label_1; + } + iL[7] = (iL[4] + 2); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[7]); + label_37: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(48, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 1) & 0xFF)) != 0) { + break label_37; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[7], iL[5]) != 0) { + break label_37; + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) (iL[4] + 3)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(120, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 2) & 0xFF)) != 0) { + break label_37; + } + long[] callArgs_17 = new long[3]; + callArgs_17[2] = ((long) 58); + callArgs_17[1] = ((long) iL[1]); + callArgs_17[0] = ((long) iL[0]); + instance.getMachine().call(567, callArgs_17); + break label_1; + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[8]); + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) 58); + callArgs_18[1] = ((long) iL[1]); + callArgs_18[0] = ((long) iL[0]); + instance.getMachine().call(561, callArgs_18); + break label_1; + } + iL[8] = (iL[4] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[8]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(59, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF)) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[8], iL[5]) != 0) { + break label_7; + } + iL[8] = (iL[4] + 2); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[8]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(59, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 1) & 0xFF)) != 0) { + break label_7; + } + iL[10] = (iL[4] + 2); + label_38: { + label_39: { + label_40: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[8], iL[5]) != 0) { + break label_38; + } + iL[9] = (iL[8] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[9]); + iL[11] = ((int) memory.read((int) iL[8] < 0 ? iL[8] : iL[8] + 0) & 0xFF); + iL[10] = (iL[10] + 1); + iL[8] = iL[9]; + label_41: { + switch((iL[11] + -10)) { + case 0: + { + break label_39; + } + case 1: + { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_40; + } + case 2: + { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_40; + } + case 3: + { + break label_41; + } + default: + { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_40; + } + } + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[5]) != 0) { + break label_39; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(10, ((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF)) != 0) { + break label_39; + } + iL[9] = (iL[9] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[9]); + } + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) iL[9]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 16, (int) (memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16) + 1)); + break label_4; + } + iL[5] = ((iL[3] + 288) + 8); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[8] = memory.readInt((int) (iL[1] + 28) < 0 ? (iL[1] + 28) : (iL[1] + 28) + 0); + iL[4] = (iL[4] - iL[8]); + memory.writeI32((int) (iL[3] + 300) < 0 ? (iL[3] + 300) : (iL[3] + 300) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1)); + iL[4] = (iL[10] - iL[8]); + iL[8] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1); + memory.writeI32((int) ((iL[3] + 288) + 16) < 0 ? ((iL[3] + 288) + 16) : ((iL[3] + 288) + 16) + 0, (int) iL[8]); + iL[7] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[4] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + memory.writeI32((int) ((iL[3] + 168) + 16) < 0 ? ((iL[3] + 168) + 16) : ((iL[3] + 168) + 16) + 0, (int) iL[8]); + memory.writeLong((int) ((iL[3] + 168) + 8) < 0 ? ((iL[3] + 168) + 8) : ((iL[3] + 168) + 8) + 0, (long) memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[1] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[4]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 292, (int) (iL[1] != 0 ? iL[9] : iL[4])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 288, (int) (iL[1] != 0 ? iL[7] : iL[6])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 168, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 288)); + long[] callArgs_19 = new long[3]; + callArgs_19[2] = ((long) 19); + callArgs_19[1] = ((long) (iL[3] + 168)); + callArgs_19[0] = ((long) iL[0]); + long[] callResult_19 = instance.getMachine().call(539, callArgs_19); + break label_1; + } + iL[5] = (iL[4] + iL[9]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[5]); + iL[8] = ((iL[3] + 264) + 8); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[9] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0); + iL[5] = (iL[5] - iL[9]); + iL[10] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[5], 0) != 0 ? iL[5] : 0) + 1); + memory.writeI32((int) ((iL[3] + 264) + 16) < 0 ? ((iL[3] + 264) + 16) : ((iL[3] + 264) + 16) + 0, (int) iL[10]); + iL[11] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[12] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[5] = (int) (byte) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15); + memory.writeI32((int) ((iL[3] + 192) + 16) < 0 ? ((iL[3] + 192) + 16) : ((iL[3] + 192) + 16) + 0, (int) iL[10]); + iL[4] = (iL[4] - iL[9]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 276, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1)); + memory.writeLong((int) ((iL[3] + 192) + 8) < 0 ? ((iL[3] + 192) + 8) : ((iL[3] + 192) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + iL[4] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[5], 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 268, (int) (iL[4] != 0 ? iL[12] : (iL[5] & 255))); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 264, (int) (iL[4] != 0 ? iL[11] : iL[6])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 192, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 264)); + long[] callArgs_20 = new long[4]; + callArgs_20[3] = ((long) 0); + callArgs_20[2] = ((long) 11782); + callArgs_20[1] = ((long) (iL[3] + 192)); + callArgs_20[0] = ((long) iL[1]); + instance.getMachine().call(566, callArgs_20); + break label_4; + } + iL[8] = (iL[4] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[8]); + label_42: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(40, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF)) != 0) { + break label_42; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[8], iL[5]) != 0) { + break label_42; + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) (iL[4] + 2)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(59, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 1) & 0xFF)) != 0) { + break label_42; + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) iL[1]); + long[] callResult_21 = instance.getMachine().call(568, callArgs_21); + if (((int) callResult_21[0]) != 0) { + break label_4; + } + iL[5] = ((iL[3] + 288) + 8); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[4] = memory.readInt((int) (iL[1] + 28) < 0 ? (iL[1] + 28) : (iL[1] + 28) + 0); + iL[8] = (memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 32) - iL[4]); + memory.writeI32((int) (iL[3] + 300) < 0 ? (iL[3] + 300) : (iL[3] + 300) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[8], 0) != 0 ? iL[8] : 0) + 1)); + iL[4] = (memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36) - iL[4]); + iL[8] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1); + memory.writeI32((int) ((iL[3] + 288) + 16) < 0 ? ((iL[3] + 288) + 16) : ((iL[3] + 288) + 16) + 0, (int) iL[8]); + iL[7] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[4] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + memory.writeI32((int) ((iL[3] + 64) + 16) < 0 ? ((iL[3] + 64) + 16) : ((iL[3] + 64) + 16) + 0, (int) iL[8]); + memory.writeLong((int) ((iL[3] + 64) + 8) < 0 ? ((iL[3] + 64) + 8) : ((iL[3] + 64) + 8) + 0, (long) memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[1] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[4]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 292, (int) (iL[1] != 0 ? iL[9] : iL[4])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 288, (int) (iL[1] != 0 ? iL[7] : iL[6])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 64, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 288)); + long[] callArgs_22 = new long[3]; + callArgs_22[2] = ((long) 19); + callArgs_22[1] = ((long) (iL[3] + 64)); + callArgs_22[0] = ((long) iL[0]); + long[] callResult_22 = instance.getMachine().call(539, callArgs_22); + break label_1; + } + iL[8] = (iL[4] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[8]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(40, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF)) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[8], iL[5]) != 0) { + break label_5; + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) (iL[4] + 2)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(64, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 1) & 0xFF)) != 0) { + break label_5; + } + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) iL[1]); + callArgs_23[0] = ((long) (iL[3] + 288)); + instance.getMachine().call(563, callArgs_23); + iL[8] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36); + iL[5] = memory.readInt((int) (iL[1] + 28) < 0 ? (iL[1] + 28) : (iL[1] + 28) + 0); + iL[4] = (iL[8] - iL[5]); + memory.writeI32((int) (iL[3] + 304) < 0 ? (iL[3] + 304) : (iL[3] + 304) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1)); + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 32); + iL[5] = (iL[4] - iL[5]); + memory.writeI32((int) (iL[3] + 300) < 0 ? (iL[3] + 300) : (iL[3] + 300) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[5], 0) != 0 ? iL[5] : 0) + 1)); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 296, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[5] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + iL[2] = iL[5]; + iL[5] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[5]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 292, (int) (iL[5] != 0 ? memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8) : iL[2])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 288, (int) (iL[5] != 0 ? memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4) : iL[6])); + label_43: { + label_44: { + iL[5] = (iL[4] + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[5], memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 24)) != 0) { + break label_44; + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 328, (long) 0L); + break label_43; + } + label_45: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[8], iL[5]) != 0) { + break label_45; + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 328, (long) 0L); + break label_43; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 328, (int) iL[5]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 332, (int) ((iL[8] - iL[4]) + -2)); + } + memory.writeI32((int) ((iL[3] + 96) + 16) < 0 ? ((iL[3] + 96) + 16) : ((iL[3] + 96) + 16) + 0, (int) memory.readInt((int) ((iL[3] + 288) + 16) < 0 ? ((iL[3] + 288) + 16) : ((iL[3] + 288) + 16) + 0)); + memory.writeLong((int) ((iL[3] + 96) + 8) < 0 ? ((iL[3] + 96) + 8) : ((iL[3] + 96) + 8) + 0, (long) memory.readLong((int) ((iL[3] + 288) + 8) < 0 ? ((iL[3] + 288) + 8) : ((iL[3] + 288) + 8) + 0)); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 96, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 288)); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 88, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 328)); + long[] callArgs_24 = new long[4]; + callArgs_24[3] = ((long) (iL[3] + 88)); + callArgs_24[2] = ((long) 132); + callArgs_24[1] = ((long) (iL[3] + 96)); + callArgs_24[0] = ((long) iL[0]); + long[] callResult_24 = instance.getMachine().call(541, callArgs_24); + break label_1; + } + iL[5] = (iL[4] + iL[9]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[5]); + iL[8] = ((iL[3] + 288) + 8); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[7] = memory.readInt((int) (iL[1] + 28) < 0 ? (iL[1] + 28) : (iL[1] + 28) + 0); + iL[4] = (iL[4] - iL[7]); + memory.writeI32((int) (iL[3] + 300) < 0 ? (iL[3] + 300) : (iL[3] + 300) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1)); + iL[4] = (iL[5] - iL[7]); + iL[5] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1); + memory.writeI32((int) ((iL[3] + 288) + 16) < 0 ? ((iL[3] + 288) + 16) : ((iL[3] + 288) + 16) + 0, (int) iL[5]); + iL[7] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[4] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + memory.writeI32((int) ((iL[3] + 120) + 16) < 0 ? ((iL[3] + 120) + 16) : ((iL[3] + 120) + 16) + 0, (int) iL[5]); + memory.writeLong((int) ((iL[3] + 120) + 8) < 0 ? ((iL[3] + 120) + 8) : ((iL[3] + 120) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + iL[1] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[4]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 292, (int) (iL[1] != 0 ? iL[9] : iL[4])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 288, (int) (iL[1] != 0 ? iL[7] : iL[6])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 120, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 288)); + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) 30); + callArgs_25[1] = ((long) (iL[3] + 120)); + callArgs_25[0] = ((long) iL[0]); + long[] callResult_25 = instance.getMachine().call(539, callArgs_25); + break label_1; + } + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 32, (int) iL[4]); + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[4], iL[5]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + iL[8] = ((iL[3] + 288) + 8); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[4] = (iL[4] - memory.readInt((int) (iL[1] + 28) < 0 ? (iL[1] + 28) : (iL[1] + 28) + 0)); + iL[4] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1); + memory.writeI32((int) (iL[3] + 300) < 0 ? (iL[3] + 300) : (iL[3] + 300) + 0, (int) iL[4]); + memory.writeI32((int) ((iL[3] + 288) + 16) < 0 ? ((iL[3] + 288) + 16) : ((iL[3] + 288) + 16) + 0, (int) iL[4]); + iL[7] = memory.readInt((int) (iL[1] + 8) < 0 ? (iL[1] + 8) : (iL[1] + 8) + 0); + iL[6] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[5] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + memory.writeI32((int) ((iL[3] + 8) + 16) < 0 ? ((iL[3] + 8) + 16) : ((iL[3] + 8) + 16) + 0, (int) iL[4]); + memory.writeLong((int) ((iL[3] + 8) + 8) < 0 ? ((iL[3] + 8) + 8) : ((iL[3] + 8) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + iL[4] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[5]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 292, (int) (iL[4] != 0 ? iL[7] : iL[5])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 288, (int) (iL[4] != 0 ? iL[6] : (iL[1] + 4))); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 8, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 288)); + long[] callArgs_26 = new long[3]; + callArgs_26[2] = ((long) 19); + callArgs_26[1] = ((long) (iL[3] + 8)); + callArgs_26[0] = ((long) iL[0]); + long[] callResult_26 = instance.getMachine().call(539, callArgs_26); + } + instance.global(0).setValue(((long) (iL[3] + 336))); + return; + } + + public static long[] call_557(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_557(arg0, arg1, memory, instance); + return null; + } + + public static void func_558(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[16]; + iL[0] = arg0; + iL[1] = arg1; + iL[3] = (((int) instance.global(0).getValue()) - 304); + instance.global(0).setValue(((long) iL[3])); + label_1: { + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[4], memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 24)) != 0) { + break label_1; + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) (iL[4] + 1)); + } + iL[5] = (iL[1] + 4); + label_2: { + label_3: { + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36); + iL[6] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[4], iL[6]) != 0) { + break label_3; + } + iL[7] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 32); + iL[8] = (iL[1] + 28); + iL[9] = 0; + label_4: while (true) { + iL[10] = (iL[4] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[10]); + label_5: { + label_6: { + label_7: { + label_8: { + int _d0 = func_558__h0(iL, memory, instance); + if (_d0 == 1) + break label_5; + if (_d0 == 2) + break label_7; + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 32, (int) iL[7]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[9] & 1)) != 0) { + break label_6; + } + } + iL[4] = ((iL[3] + 176) + 8); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[10] = memory.readInt((int) (iL[1] + 28) < 0 ? (iL[1] + 28) : (iL[1] + 28) + 0); + iL[11] = (iL[7] - iL[10]); + memory.writeI32((int) (iL[3] + 188) < 0 ? (iL[3] + 188) : (iL[3] + 188) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[11], 0) != 0 ? iL[11] : 0) + 1)); + iL[10] = (memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36) - iL[10]); + iL[10] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[10], 0) != 0 ? iL[10] : 0) + 1); + memory.writeI32((int) ((iL[3] + 176) + 16) < 0 ? ((iL[3] + 176) + 16) : ((iL[3] + 176) + 16) + 0, (int) iL[10]); + iL[11] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[6] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + memory.writeI32((int) ((iL[3] + 96) + 16) < 0 ? ((iL[3] + 96) + 16) : ((iL[3] + 96) + 16) + 0, (int) iL[10]); + memory.writeLong((int) ((iL[3] + 96) + 8) < 0 ? ((iL[3] + 96) + 8) : ((iL[3] + 96) + 8) + 0, (long) memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + iL[4] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[1]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 180, (int) (iL[4] != 0 ? iL[6] : iL[1])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 176, (int) (iL[4] != 0 ? iL[11] : iL[5])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 96, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 176)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) (iL[3] + 96)); + callArgs_4[0] = ((long) iL[0]); + long[] callResult_4 = instance.getMachine().call(539, callArgs_4); + break label_2; + } + iL[11] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36); + iL[4] = memory.readInt((int) (iL[1] + 28) < 0 ? (iL[1] + 28) : (iL[1] + 28) + 0); + iL[10] = (iL[11] - iL[4]); + memory.writeI32((int) (iL[3] + 296) < 0 ? (iL[3] + 296) : (iL[3] + 296) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[10], 0) != 0 ? iL[10] : 0) + 1)); + iL[4] = (iL[7] - iL[4]); + memory.writeI32((int) (iL[3] + 292) < 0 ? (iL[3] + 292) : (iL[3] + 292) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1)); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 288, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[4] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + iL[2] = iL[4]; + iL[4] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[4]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 284, (int) (iL[4] != 0 ? memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8) : iL[2])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 280, (int) (iL[4] != 0 ? memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4) : iL[5])); + label_20: { + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[7], memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 24)) != 0) { + break label_21; + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 272, (long) 0L); + break label_20; + } + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[11], iL[7]) != 0) { + break label_22; + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 272, (long) 0L); + break label_20; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 272, (int) iL[7]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 276, (int) (iL[11] - iL[7])); + } + memory.writeI32((int) ((iL[3] + 152) + 16) < 0 ? ((iL[3] + 152) + 16) : ((iL[3] + 152) + 16) + 0, (int) memory.readInt((int) ((iL[3] + 280) + 16) < 0 ? ((iL[3] + 280) + 16) : ((iL[3] + 280) + 16) + 0)); + memory.writeLong((int) ((iL[3] + 152) + 8) < 0 ? ((iL[3] + 152) + 8) : ((iL[3] + 152) + 8) + 0, (long) memory.readLong((int) ((iL[3] + 280) + 8) < 0 ? ((iL[3] + 280) + 8) : ((iL[3] + 280) + 8) + 0)); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 152, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 280)); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 144, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 272)); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (iL[3] + 144)); + callArgs_5[2] = ((long) 135); + callArgs_5[1] = ((long) (iL[3] + 152)); + callArgs_5[0] = ((long) iL[0]); + long[] callResult_5 = instance.getMachine().call(541, callArgs_5); + break label_2; + } + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36); + iL[6] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[4], iL[6]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + iL[10] = ((iL[3] + 280) + 8); + memory.writeI32((int) iL[10] < 0 ? iL[10] : iL[10] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[11] = memory.readInt((int) (iL[1] + 28) < 0 ? (iL[1] + 28) : (iL[1] + 28) + 0); + iL[6] = (memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 32) - iL[11]); + memory.writeI32((int) (iL[3] + 292) < 0 ? (iL[3] + 292) : (iL[3] + 292) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[6], 0) != 0 ? iL[6] : 0) + 1)); + iL[4] = (iL[4] - iL[11]); + iL[4] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1); + memory.writeI32((int) ((iL[3] + 280) + 16) < 0 ? ((iL[3] + 280) + 16) : ((iL[3] + 280) + 16) + 0, (int) iL[4]); + iL[11] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[6] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + memory.writeI32((int) ((iL[3] + 8) + 16) < 0 ? ((iL[3] + 8) + 16) : ((iL[3] + 8) + 16) + 0, (int) iL[4]); + memory.writeLong((int) ((iL[3] + 8) + 8) < 0 ? ((iL[3] + 8) + 8) : ((iL[3] + 8) + 8) + 0, (long) memory.readLong((int) iL[10] < 0 ? iL[10] : iL[10] + 0)); + iL[4] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[1]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 284, (int) (iL[4] != 0 ? iL[6] : iL[1])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 280, (int) (iL[4] != 0 ? iL[11] : iL[5])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 8, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 280)); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 19); + callArgs_6[1] = ((long) (iL[3] + 8)); + callArgs_6[0] = ((long) iL[0]); + long[] callResult_6 = instance.getMachine().call(539, callArgs_6); + } + instance.global(0).setValue(((long) (iL[3] + 304))); + return; + } + + public static long[] call_558(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_558(arg0, arg1, memory, instance); + return null; + } + + public static void func_559(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local4) != 0) { + break label_3; + } + local5 = (local3 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(105, ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local4) != 0) { + break label_3; + } + local5 = (local3 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(110, ((int) memory.read((int) local3 < 0 ? local3 : local3 + 1) & 0xFF)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local4) != 0) { + break label_3; + } + local5 = (local3 + 3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(102, ((int) memory.read((int) local3 < 0 ? local3 : local3 + 2) & 0xFF)) != 0) { + break label_3; + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local4) != 0) { + break label_4; + } + local3 = 0; + label_5: { + label_6: while (true) { + label_7: { + label_8: { + local6 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local6 + 43169) < 0 ? (local6 + 43169) : (local6 + 43169) + 0) & 0xFF) & 1)) != 0) { + break label_8; + } + local5 = (local5 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local5); + local3 = (local3 != 0 ? local3 : 2); + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, local6) != 0) { + break label_5; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local2 + 24)); + instance.getMachine().call(558, callArgs_0); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local3 = 1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break label_2; + } + } + if (local3 != 0) { + break label_2; + } + } + local7 = ((local2 + 24) + 8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local6 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local8 = (local3 - local6); + memory.writeI32((int) (local2 + 36) < 0 ? (local2 + 36) : (local2 + 36) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local8, 0) != 0 ? local8 : 0) + 1)); + local6 = (local5 - local6); + local8 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local6, 0) != 0 ? local6 : 0) + 1); + memory.writeI32((int) ((local2 + 24) + 16) < 0 ? ((local2 + 24) + 16) : ((local2 + 24) + 16) + 0, (int) local8); + local9 = memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0); + local10 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local6 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) local8); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6), 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) (local8 != 0 ? local9 : local6)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) (local8 != 0 ? local10 : (arg1 + 4))); + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) & com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, local3)); + memory.writeI32((int) ((local2 + 64) + 8) < 0 ? ((local2 + 64) + 8) : ((local2 + 64) + 8) + 0, (int) (arg1 != 0 ? (local5 - local3) : 0)); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 24)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 68, (int) (arg1 != 0 ? local3 : 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 64, (int) 3); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local2 + 64)); + callArgs_1[2] = ((long) 57); + callArgs_1[1] = ((long) local2); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(543, callArgs_1); + break label_1; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local3); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(565, callArgs_2); + break label_1; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(562, callArgs_3); + } + instance.global(0).setValue(((long) (local2 + 80))); + return; + } + + public static long[] call_559(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_559(arg0, arg1, memory, instance); + return null; + } + + public static void func_560(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local4) != 0) { + break label_3; + } + local5 = (local3 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(110, ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local4) != 0) { + break label_3; + } + local5 = (local3 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(97, ((int) memory.read((int) local3 < 0 ? local3 : local3 + 1) & 0xFF)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local4) != 0) { + break label_3; + } + local5 = (local3 + 3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(110, ((int) memory.read((int) local3 < 0 ? local3 : local3 + 2) & 0xFF)) != 0) { + break label_3; + } + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local4) != 0) { + break label_5; + } + label_6: { + label_7: { + local6 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(58, local6) != 0) { + break label_7; + } + local3 = 0; + break label_6; + } + local5 = (local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local4) != 0) { + break label_2; + } + local6 = (local3 + 5); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(48, ((int) memory.read((int) local3 < 0 ? local3 : local3 + 4) & 0xFF)) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local4) != 0) { + break label_2; + } + local6 = (local3 + 6); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(120, ((int) memory.read((int) local3 < 0 ? local3 : local3 + 5) & 0xFF)) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local4) != 0) { + break label_4; + } + label_8: { + label_9: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) : (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 4)) != 0) { + break label_4; + } + local3 = (local6 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local4) != 0) { + break label_8; + } + label_10: { + label_11: { + label_12: { + local5 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(95, local5) != 0) { + break label_12; + } + local6 = (local6 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local5 + 43169) < 0 ? (local5 + 43169) : (local5 + 43169) + 0) & 0xFF) & 4)) != 0) { + break label_10; + } + local6 = local3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break label_4; + } + break; + } + local5 = 0; + label_13: { + label_14: while (true) { + label_15: { + label_16: { + local6 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local6 + 43169) < 0 ? (local6 + 43169) : (local6 + 43169) + 0) & 0xFF) & 1)) != 0) { + break label_16; + } + local3 = (local3 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local3); + local5 = (local5 != 0 ? local5 : 2); + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, local6) != 0) { + break label_13; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local2 + 56)); + instance.getMachine().call(558, callArgs_0); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local5 = 1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break label_4; + } + } + if (local5 != 0) { + break label_4; + } + } + local7 = ((local2 + 56) + 8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local6 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local8 = (local5 - local6); + memory.writeI32((int) (local2 + 68) < 0 ? (local2 + 68) : (local2 + 68) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local8, 0) != 0 ? local8 : 0) + 1)); + local6 = (local3 - local6); + local8 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local6, 0) != 0 ? local6 : 0) + 1); + memory.writeI32((int) ((local2 + 56) + 16) < 0 ? ((local2 + 56) + 16) : ((local2 + 56) + 16) + 0, (int) local8); + local9 = memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0); + local10 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local6 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) local8); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6), 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 60, (int) (local8 != 0 ? local9 : local6)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) (local8 != 0 ? local10 : (arg1 + 4))); + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local4) & com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, local5)); + memory.writeI32((int) ((local2 + 96) + 8) < 0 ? ((local2 + 96) + 8) : ((local2 + 96) + 8) + 0, (int) (arg1 != 0 ? (local3 - local5) : 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 100, (int) (arg1 != 0 ? local5 : 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) 4); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local2 + 96)); + callArgs_1[2] = ((long) 57); + callArgs_1[1] = ((long) (local2 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(543, callArgs_1); + break label_1; + } + label_17: { + label_18: while (true) { + label_19: { + label_20: { + local6 = (local6 & 255); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local6 + 43169) < 0 ? (local6 + 43169) : (local6 + 43169) + 0) & 0xFF) & 1)) != 0) { + break label_20; + } + local5 = (local5 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local5); + local3 = (local3 != 0 ? local3 : 2); + break label_19; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, local6) != 0) { + break label_17; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) (local2 + 56)); + instance.getMachine().call(558, callArgs_2); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local3 = 1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local4) != 0) { + break label_4; + } + local6 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + } + if (local3 != 0) { + break label_4; + } + } + local7 = ((local2 + 56) + 8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local6 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local8 = (local3 - local6); + memory.writeI32((int) (local2 + 68) < 0 ? (local2 + 68) : (local2 + 68) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local8, 0) != 0 ? local8 : 0) + 1)); + local6 = (local5 - local6); + local8 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local6, 0) != 0 ? local6 : 0) + 1); + memory.writeI32((int) ((local2 + 56) + 16) < 0 ? ((local2 + 56) + 16) : ((local2 + 56) + 16) + 0, (int) local8); + local9 = memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0); + local10 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local6 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + memory.writeI32((int) ((local2 + 32) + 16) < 0 ? ((local2 + 32) + 16) : ((local2 + 32) + 16) + 0, (int) local8); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6), 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 60, (int) (local8 != 0 ? local9 : local6)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) (local8 != 0 ? local10 : (arg1 + 4))); + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) & com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, local3)); + memory.writeI32((int) ((local2 + 96) + 8) < 0 ? ((local2 + 96) + 8) : ((local2 + 96) + 8) + 0, (int) (arg1 != 0 ? (local5 - local3) : 0)); + memory.writeLong((int) ((local2 + 32) + 8) < 0 ? ((local2 + 32) + 8) : ((local2 + 32) + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 100, (int) (arg1 != 0 ? local3 : 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) 4); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) (local2 + 96)); + callArgs_3[2] = ((long) 57); + callArgs_3[1] = ((long) (local2 + 32)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(543, callArgs_3); + break label_1; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(565, callArgs_4); + break label_1; + } + local5 = local3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local5); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(565, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 112))); + return; + } + + public static long[] call_560(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_560(arg0, arg1, memory, instance); + return null; + } + + public static void func_561(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_1 = 0; + int _snap_0 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_2; + } + label_3: { + label_4: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) : (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 8)) != 0) { + break label_2; + } + local6 = (local4 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local5) != 0) { + break label_3; + } + label_5: { + label_6: { + label_7: { + local7 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(95, local7) != 0) { + break label_7; + } + local4 = (local4 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local7 + 43169) < 0 ? (local7 + 43169) : (local7 + 43169) + 0) & 0xFF) & 8)) != 0) { + break label_5; + } + local4 = local6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break label_2; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(46, ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF)) != 0) { + break label_3; + } + local6 = (local4 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + arg2 = 57; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local5) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) : (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 8)) != 0) { + break label_3; + } + label_8: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) : (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 8)) != 0) { + break label_2; + } + local4 = (local6 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + local7 = 0; + label_9: { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_10; + } + label_11: { + local7 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(95, local7) != 0) { + break label_11; + } + local4 = (local6 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + break label_9; + } + local7 = (local7 + 1); + } + if ((((int) memory.read((int) (local7 + 43168) < 0 ? (local7 + 43168) : (local7 + 43168) + 0) & 0xFF) & 8) != 0) { + break label_9; + } + local6 = local4; + break label_3; + } + local6 = local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_2; + } + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local5) != 0) { + break label_12; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(101, ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF)) != 0) { + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(69, ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF)) != 0) { + break label_12; + } + } + local4 = (local6 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_14; + } + label_15: { + switch((((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + -43)) { + case 0: + { + break label_15; + } + case 1: + { + break label_14; + } + case 2: + { + break label_15; + } + default: + { + break label_14; + } + } + } + local4 = (local6 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_2; + } + label_16: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) : (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 8)) != 0) { + break label_2; + } + local6 = (local4 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + local7 = 0; + label_17: { + label_18: { + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local5) != 0) { + break label_19; + } + label_20: { + local7 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(95, local7) != 0) { + break label_20; + } + local4 = (local4 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + break label_18; + } + local7 = (local7 + 1); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local7 + 43168) < 0 ? (local7 + 43168) : (local7 + 43168) + 0) & 0xFF) & 8)) != 0) { + break label_17; + } + local4 = local6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + break label_2; + } + break; + } + arg2 = 57; + } + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local5) != 0) { + break label_21; + } + local4 = 0; + label_22: { + label_23: while (true) { + label_24: { + label_25: { + local7 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local7 + 43169) < 0 ? (local7 + 43169) : (local7 + 43169) + 0) & 0xFF) & 1)) != 0) { + break label_25; + } + local6 = (local6 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + local4 = (local4 != 0 ? local4 : 2); + break label_24; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, local7) != 0) { + break label_22; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local3 + 56)); + instance.getMachine().call(558, callArgs_0); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local4 = 1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break label_2; + } + } + if (local4 != 0) { + break label_2; + } + } + local7 = (arg1 + 4); + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(57, arg2) != 0) { + break label_26; + } + arg2 = ((local3 + 56) + 8); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local8 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local9 = (local4 - local8); + memory.writeI32((int) (local3 + 68) < 0 ? (local3 + 68) : (local3 + 68) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local9, 0) != 0 ? local9 : 0) + 1)); + local8 = (local6 - local8); + local8 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local8, 0) != 0 ? local8 : 0) + 1); + memory.writeI32((int) ((local3 + 56) + 16) < 0 ? ((local3 + 56) + 16) : ((local3 + 56) + 16) + 0, (int) local8); + local9 = memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0); + local10 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + arg1 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) local8); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 60, (int) (local8 != 0 ? local9 : arg1)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) (local8 != 0 ? local10 : local7)); + _snap_0 = local6; + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) & com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local4)); + memory.writeI32((int) ((local3 + 96) + 8) < 0 ? ((local3 + 96) + 8) : ((local3 + 96) + 8) + 0, (int) (local6 != 0 ? (_snap_0 - local4) : 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 56)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 100, (int) (local6 != 0 ? local4 : 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 96, (int) 1); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 96)); + callArgs_1[2] = ((long) 57); + callArgs_1[1] = ((long) (local3 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(543, callArgs_1); + break label_1; + } + local8 = ((local3 + 56) + 8); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local9 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local10 = (local4 - local9); + memory.writeI32((int) (local3 + 68) < 0 ? (local3 + 68) : (local3 + 68) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local10, 0) != 0 ? local10 : 0) + 1)); + local9 = (local6 - local9); + local9 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local9, 0) != 0 ? local9 : 0) + 1); + memory.writeI32((int) ((local3 + 56) + 16) < 0 ? ((local3 + 56) + 16) : ((local3 + 56) + 16) + 0, (int) local9); + local10 = memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0); + local11 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + arg1 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + memory.writeI32((int) ((local3 + 32) + 16) < 0 ? ((local3 + 32) + 16) : ((local3 + 32) + 16) + 0, (int) local9); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 60, (int) (local9 != 0 ? local10 : arg1)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) (local9 != 0 ? local11 : local7)); + _snap_1 = local6; + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) & com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local4)); + memory.writeI32((int) ((local3 + 96) + 8) < 0 ? ((local3 + 96) + 8) : ((local3 + 96) + 8) + 0, (int) (local6 != 0 ? (_snap_1 - local4) : 0)); + memory.writeLong((int) ((local3 + 32) + 8) < 0 ? ((local3 + 32) + 8) : ((local3 + 32) + 8) + 0, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 56)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 100, (int) (local6 != 0 ? local4 : 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 96, (int) 0); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local3 + 96)); + callArgs_2[2] = ((long) arg2); + callArgs_2[1] = ((long) (local3 + 32)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(543, callArgs_2); + break label_1; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(562, callArgs_3); + } + instance.global(0).setValue(((long) (local3 + 112))); + return; + } + + public static long[] call_561(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_561(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_562(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local4) != 0) { + break label_1; + } + label_2: while (true) { + label_3: { + label_4: { + local5 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local5 + 43169) < 0 ? (local5 + 43169) : (local5 + 43169) + 0) & 0xFF) & 1)) != 0) { + break label_4; + } + local3 = (local3 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local3); + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, local5) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local2 + 32)); + instance.getMachine().call(558, callArgs_0); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + local6 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local5 = (local3 - local6); + memory.writeI32((int) (local2 + 48) < 0 ? (local2 + 48) : (local2 + 48) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local5, 0) != 0 ? local5 : 0) + 1)); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local6 = (local5 - local6); + memory.writeI32((int) (local2 + 44) < 0 ? (local2 + 44) : (local2 + 44) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local6, 0) != 0 ? local6 : 0) + 1)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local6 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + _snap_0 = local6; + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6), 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) (local6 != 0 ? memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0) : _snap_0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) (local6 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : (arg1 + 4))); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local4) != 0) { + break label_6; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) 0L); + break label_5; + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, local5) != 0) { + break label_7; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) 0L); + break label_5; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 72, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 76, (int) (local3 - local5)); + } + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) ((local2 + 32) + 16) < 0 ? ((local2 + 32) + 16) : ((local2 + 32) + 16) + 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) ((local2 + 32) + 8) < 0 ? ((local2 + 32) + 8) : ((local2 + 32) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 32)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 134); + callArgs_1[1] = ((long) (local2 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(541, callArgs_1); + instance.global(0).setValue(((long) (local2 + 80))); + return; + } + + public static long[] call_562(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_562(arg0, arg1, memory, instance); + return null; + } + + public static void func_563(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_1 = 0; + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local4) != 0) { + break label_2; + } + local5 = 0; + label_3: { + label_4: while (true) { + label_5: { + label_6: { + local6 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local6 + 43169) < 0 ? (local6 + 43169) : (local6 + 43169) + 0) & 0xFF) & 1)) != 0) { + break label_6; + } + local3 = (local3 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local3); + local5 = (local5 != 0 ? local5 : 2); + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, local6) != 0) { + break label_3; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local2 + 64)); + instance.getMachine().call(558, callArgs_0); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local5 = 1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(2, local5) != 0) { + break label_2; + } + local6 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local5 = (local3 - local6); + memory.writeI32((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local5, 0) != 0 ? local5 : 0) + 1)); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local6 = (local5 - local6); + memory.writeI32((int) (local2 + 76) < 0 ? (local2 + 76) : (local2 + 76) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local6, 0) != 0 ? local6 : 0) + 1)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 72, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local6 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + _snap_0 = local6; + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6), 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 68, (int) (local6 != 0 ? memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0) : _snap_0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 64, (int) (local6 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : (arg1 + 4))); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local4) != 0) { + break label_8; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 104, (long) 0L); + break label_7; + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, local5) != 0) { + break label_9; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 104, (long) 0L); + break label_7; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 104, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 108, (int) (local3 - local5)); + } + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) ((local2 + 64) + 16) < 0 ? ((local2 + 64) + 16) : ((local2 + 64) + 16) + 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) ((local2 + 64) + 8) < 0 ? ((local2 + 64) + 8) : ((local2 + 64) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 136); + callArgs_1[1] = ((long) (local2 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(541, callArgs_1); + break label_1; + } + local6 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local5 = (local3 - local6); + memory.writeI32((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local5, 0) != 0 ? local5 : 0) + 1)); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local6 = (local5 - local6); + memory.writeI32((int) (local2 + 76) < 0 ? (local2 + 76) : (local2 + 76) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local6, 0) != 0 ? local6 : 0) + 1)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 72, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local6 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + _snap_1 = local6; + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6), 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 68, (int) (local6 != 0 ? memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0) : _snap_1)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 64, (int) (local6 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : (arg1 + 4))); + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local4) != 0) { + break label_11; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 104, (long) 0L); + break label_10; + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, local5) != 0) { + break label_12; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 104, (long) 0L); + break label_10; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 104, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 108, (int) (local3 - local5)); + } + memory.writeI32((int) ((local2 + 40) + 16) < 0 ? ((local2 + 40) + 16) : ((local2 + 40) + 16) + 0, (int) memory.readInt((int) ((local2 + 64) + 16) < 0 ? ((local2 + 64) + 16) : ((local2 + 64) + 16) + 0)); + memory.writeLong((int) ((local2 + 40) + 8) < 0 ? ((local2 + 40) + 8) : ((local2 + 40) + 8) + 0, (long) memory.readLong((int) ((local2 + 64) + 8) < 0 ? ((local2 + 64) + 8) : ((local2 + 64) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local2 + 32)); + callArgs_2[2] = ((long) 134); + callArgs_2[1] = ((long) (local2 + 40)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(541, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 112))); + return; + } + + public static long[] call_563(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_563(arg0, arg1, memory, instance); + return null; + } + + public static void func_564(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_1 = 0; + int _snap_0 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local4 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + local8 = (int) (local7 >>> 32L); + if (local8 != 0) { + break label_6; + } + arg2 = local6; + break label_5; + } + local9 = (int) local7; + local10 = local8; + arg2 = local6; + label_7: while (true) { + local11 = (int) (byte) memory.read((int) local9 < 0 ? local9 : local9 + 0); + label_8: { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, local5) != 0) { + break label_9; + } + local12 = -1; + break label_8; + } + local13 = (arg2 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local13); + local12 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF); + arg2 = local13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, local12) != 0) { + break label_4; + } + local9 = (local9 + 1); + local10 = (local10 + -1); + if (local10 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, local5) != 0) { + break label_3; + } + local6 = arg2; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + break label_2; + } + local9 = (arg2 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local9); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(48, ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF)) != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, local5) != 0) { + break label_10; + } + local9 = (arg2 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(120, ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 1) & 0xFF)) != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, local5) != 0) { + break label_2; + } + label_11: { + label_12: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) local9 < 0 ? local9 : local9 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) local9 < 0 ? local9 : local9 + 0) & 0xFF) + 43169) : (((int) memory.read((int) local9 < 0 ? local9 : local9 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 4)) != 0) { + break label_2; + } + arg2 = (local9 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, local5) != 0) { + break label_11; + } + label_13: { + label_14: { + label_15: { + local11 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(95, local11) != 0) { + break label_15; + } + local9 = (local9 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local9); + break label_14; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local11 + 43169) < 0 ? (local11 + 43169) : (local11 + 43169) + 0) & 0xFF) & 4)) != 0) { + break label_13; + } + local9 = arg2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, local5) != 0) { + break label_2; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break; + } + local9 = 0; + label_16: { + label_17: while (true) { + label_18: { + label_19: { + local11 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local11 + 43169) < 0 ? (local11 + 43169) : (local11 + 43169) + 0) & 0xFF) & 1)) != 0) { + break label_19; + } + arg2 = (arg2 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) arg2); + local9 = (local9 != 0 ? local9 : 2); + break label_18; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, local11) != 0) { + break label_16; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local4 + 64)); + instance.getMachine().call(558, callArgs_0); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local9 = 1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, local5) != 0) { + break label_2; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_17; + } + } + if (local9 != 0) { + break label_2; + } + } + local9 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local11 = (arg2 - local9); + memory.writeI32((int) (local4 + 80) < 0 ? (local4 + 80) : (local4 + 80) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local11, 0) != 0 ? local11 : 0) + 1)); + local11 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local9 = (local11 - local9); + memory.writeI32((int) (local4 + 76) < 0 ? (local4 + 76) : (local4 + 76) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local9, 0) != 0 ? local9 : 0) + 1)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 72, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local9 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + _snap_0 = local9; + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local9), 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 68, (int) (local9 != 0 ? memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0) : _snap_0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 64, (int) (local9 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : (arg1 + 4))); + label_20: { + label_21: { + local9 = (local11 + local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, local5) != 0) { + break label_21; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + break label_20; + } + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, local9) != 0) { + break label_22; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + break label_20; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 104, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 108, (int) (arg2 - local9)); + } + memory.writeI32((int) ((local4 + 8) + 16) < 0 ? ((local4 + 8) + 16) : ((local4 + 8) + 16) + 0, (int) memory.readInt((int) ((local4 + 64) + 16) < 0 ? ((local4 + 64) + 16) : ((local4 + 64) + 16) + 0)); + memory.writeLong((int) ((local4 + 8) + 8) < 0 ? ((local4 + 8) + 8) : ((local4 + 8) + 8) + 0, (long) memory.readLong((int) ((local4 + 64) + 8) < 0 ? ((local4 + 64) + 8) : ((local4 + 64) + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 64)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 104)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local4); + callArgs_1[2] = ((long) arg3); + callArgs_1[1] = ((long) (local4 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(541, callArgs_1); + break label_1; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) arg2); + label_23: { + label_24: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF) + 43169) : (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 8)) != 0) { + break label_2; + } + local9 = (arg2 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, local5) != 0) { + break label_23; + } + label_25: { + label_26: { + label_27: { + local11 = ((int) memory.read((int) local9 < 0 ? local9 : local9 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(95, local11) != 0) { + break label_27; + } + arg2 = (arg2 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) arg2); + break label_26; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local11 + 43169) < 0 ? (local11 + 43169) : (local11 + 43169) + 0) & 0xFF) & 8)) != 0) { + break label_25; + } + arg2 = local9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, local5) != 0) { + break label_2; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_24; + } + break; + } + arg2 = 0; + label_28: { + label_29: while (true) { + label_30: { + label_31: { + local11 = ((int) memory.read((int) local9 < 0 ? local9 : local9 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local11 + 43169) < 0 ? (local11 + 43169) : (local11 + 43169) + 0) & 0xFF) & 1)) != 0) { + break label_31; + } + local9 = (local9 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local9); + arg2 = (arg2 != 0 ? arg2 : 2); + break label_30; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, local11) != 0) { + break label_28; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) (local4 + 64)); + instance.getMachine().call(558, callArgs_2); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local9 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + arg2 = 1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, local5) != 0) { + break label_2; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_29; + } + } + if (arg2 != 0) { + break label_2; + } + } + arg2 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local11 = (local9 - arg2); + memory.writeI32((int) (local4 + 80) < 0 ? (local4 + 80) : (local4 + 80) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local11, 0) != 0 ? local11 : 0) + 1)); + local11 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + arg2 = (local11 - arg2); + memory.writeI32((int) (local4 + 76) < 0 ? (local4 + 76) : (local4 + 76) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg2, 0) != 0 ? arg2 : 0) + 1)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 72, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + arg2 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + _snap_1 = arg2; + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg2), 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 68, (int) (arg2 != 0 ? memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0) : _snap_1)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 64, (int) (arg2 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : (arg1 + 4))); + label_32: { + label_33: { + arg2 = (local11 + local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, local5) != 0) { + break label_33; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + break label_32; + } + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, arg2) != 0) { + break label_34; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + break label_32; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 104, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 108, (int) (local9 - arg2)); + } + memory.writeI32((int) ((local4 + 40) + 16) < 0 ? ((local4 + 40) + 16) : ((local4 + 40) + 16) + 0, (int) memory.readInt((int) ((local4 + 64) + 16) < 0 ? ((local4 + 64) + 16) : ((local4 + 64) + 16) + 0)); + memory.writeLong((int) ((local4 + 40) + 8) < 0 ? ((local4 + 40) + 8) : ((local4 + 40) + 8) + 0, (long) memory.readLong((int) ((local4 + 64) + 8) < 0 ? ((local4 + 64) + 8) : ((local4 + 64) + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 64)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 32, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 104)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) (local4 + 32)); + callArgs_3[2] = ((long) arg3); + callArgs_3[1] = ((long) (local4 + 40)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(541, callArgs_3); + break label_1; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(565, callArgs_4); + } + instance.global(0).setValue(((long) (local4 + 112))); + return; + } + + public static long[] call_564(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_564(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_565(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_2 = 0; + int _snap_1 = 0; + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + local2 = (((int) instance.global(0).getValue()) - 224); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local4) != 0) { + break label_1; + } + label_2: while (true) { + label_3: { + label_4: { + local5 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local5 + 43169) < 0 ? (local5 + 43169) : (local5 + 43169) + 0) & 0xFF) & 1)) != 0) { + break label_4; + } + local3 = (local3 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local3); + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, local5) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local2 + 176)); + instance.getMachine().call(558, callArgs_0); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + local5 = (arg1 + 4); + label_5: { + label_6: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local3 - local4)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(570, callArgs_1); + local3 = ((int) callResult_1[0]); + if (local3 != 0) { + break label_6; + } + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local4 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local3 = (local6 - local4); + memory.writeI32((int) (local2 + 192) < 0 ? (local2 + 192) : (local2 + 192) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local3, 0) != 0 ? local3 : 0) + 1)); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local4 = (local3 - local4); + memory.writeI32((int) (local2 + 188) < 0 ? (local2 + 188) : (local2 + 188) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local4, 0) != 0 ? local4 : 0) + 1)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 184, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + _snap_0 = local4; + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) (local4 != 0 ? memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0) : _snap_0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) (local4 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : local5)); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24)) != 0) { + break label_8; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 216, (long) 0L); + break label_7; + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local3) != 0) { + break label_9; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 216, (long) 0L); + break label_7; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 216, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 220, (int) (local6 - local3)); + } + memory.writeI32((int) ((local2 + 16) + 16) < 0 ? ((local2 + 16) + 16) : ((local2 + 16) + 16) + 0, (int) memory.readInt((int) ((local2 + 176) + 16) < 0 ? ((local2 + 176) + 16) : ((local2 + 176) + 16) + 0)); + memory.writeLong((int) ((local2 + 16) + 8) < 0 ? ((local2 + 16) + 8) : ((local2 + 16) + 8) + 0, (long) memory.readLong((int) ((local2 + 176) + 8) < 0 ? ((local2 + 176) + 8) : ((local2 + 176) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 176)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 216)); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local2 + 8)); + callArgs_2[2] = ((long) 134); + callArgs_2[1] = ((long) (local2 + 16)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(541, callArgs_2); + break label_5; + } + label_10: { + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 56) != 0) { + break label_10; + } + local6 = ((local2 + 176) + 8); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local3 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local7 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32) - local3); + memory.writeI32((int) (local2 + 188) < 0 ? (local2 + 188) : (local2 + 188) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local7, 0) != 0 ? local7 : 0) + 1)); + local3 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36) - local3); + local7 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local3, 0) != 0 ? local3 : 0) + 1); + memory.writeI32((int) ((local2 + 176) + 16) < 0 ? ((local2 + 176) + 16) : ((local2 + 176) + 16) + 0, (int) local7); + local8 = memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0); + local9 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local3 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + memory.writeI32((int) ((local2 + 40) + 16) < 0 ? ((local2 + 40) + 16) : ((local2 + 40) + 16) + 0, (int) local7); + memory.writeLong((int) ((local2 + 40) + 8) < 0 ? ((local2 + 40) + 8) : ((local2 + 40) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) (arg1 != 0 ? local8 : local3)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) (arg1 != 0 ? local9 : local5)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 176)); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local4); + callArgs_3[1] = ((long) (local2 + 40)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(539, callArgs_3); + break label_5; + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local4 + -137), 3) != 0) { + break label_11; + } + local4 = ((local2 + 152) + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local6 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local7 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32) - local6); + memory.writeI32((int) (local2 + 164) < 0 ? (local2 + 164) : (local2 + 164) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local7, 0) != 0 ? local7 : 0) + 1)); + local6 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36) - local6); + local6 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local6, 0) != 0 ? local6 : 0) + 1); + memory.writeI32((int) ((local2 + 152) + 16) < 0 ? ((local2 + 152) + 16) : ((local2 + 152) + 16) + 0, (int) local6); + local7 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + _snap_1 = local7; + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local7), 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 156, (int) (local7 != 0 ? memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0) : _snap_1)); + local8 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + local10 = memory.readLong((int) local3 < 0 ? local3 : local3 + 8); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + memory.writeLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 152, (int) (local7 != 0 ? local3 : local5)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 152)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 64, (long) local10); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 144, (long) local10); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) (local2 + 64)); + callArgs_4[2] = ((long) local8); + callArgs_4[1] = ((long) (local2 + 72)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(540, callArgs_4); + break label_5; + } + local4 = ((local2 + 120) + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local6 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local7 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32) - local6); + memory.writeI32((int) (local2 + 132) < 0 ? (local2 + 132) : (local2 + 132) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local7, 0) != 0 ? local7 : 0) + 1)); + local6 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36) - local6); + local6 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local6, 0) != 0 ? local6 : 0) + 1); + memory.writeI32((int) ((local2 + 120) + 16) < 0 ? ((local2 + 120) + 16) : ((local2 + 120) + 16) + 0, (int) local6); + local7 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + _snap_2 = local7; + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local7), 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 124, (int) (local7 != 0 ? memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0) : _snap_2)); + local8 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + local3 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + memory.writeI32((int) ((local2 + 96) + 16) < 0 ? ((local2 + 96) + 16) : ((local2 + 96) + 16) + 0, (int) local6); + memory.writeLong((int) ((local2 + 96) + 8) < 0 ? ((local2 + 96) + 8) : ((local2 + 96) + 8) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 120, (int) (local7 != 0 ? arg1 : local5)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 96, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 120)); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) local3); + callArgs_5[2] = ((long) local8); + callArgs_5[1] = ((long) (local2 + 96)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(542, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 224))); + return; + } + + public static long[] call_565(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_565(arg0, arg1, memory, instance); + return null; + } + + public static void func_566(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local4)); + local5 = local4; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 148, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 144, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) (local5 + 16)); + local6 = (local5 + 16); + label_1: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) 128); + callArgs_0[0] = ((long) (local5 + 16)); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg3 = (((int) callResult_0[0]) + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, 129) != 0) { + break label_1; + } + local6 = (local4 - ((arg3 + 15) & -16)); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local6); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 144)); + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg3); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1875, callArgs_1); + } + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) 1); + label_2: { + label_3: { + label_4: { + arg3 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 8)) != 0) { + break label_4; + } + local4 = ((local5 + 152) + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + arg0 = ((local5 + 152) + 8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 152, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) 1); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 4, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 152)); + memory.writeLong((int) (arg3 + 12) < 0 ? (arg3 + 12) : (arg3 + 12) + 0, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeI32((int) (arg3 + 20) < 0 ? (arg3 + 20) : (arg3 + 20) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 2147483632) != 0) { + break label_2; + } + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 10) != 0) { + break label_6; + } + local4 = (arg3 + 24); + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 35, (byte) (arg1)); + break label_5; + } + arg0 = ((arg1 | 15) + 1); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local4 = ((int) callResult_3[0]); + memory.writeI32((int) (arg3 + 32) < 0 ? (arg3 + 32) : (arg3 + 32) + 0, (int) (arg0 | -2147483648)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 24, (int) local4); + memory.writeI32((int) (arg3 + 28) < 0 ? (arg3 + 28) : (arg3 + 28) + 0, (int) arg1); + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg1); + callArgs_4[1] = ((long) local6); + callArgs_4[0] = ((long) local4); + long[] callResult_4 = instance.getMachine().call(1891, callArgs_4); + memory.writeByte((int) (((int) callResult_4[0]) + arg1) < 0 ? (((int) callResult_4[0]) + arg1) : (((int) callResult_4[0]) + arg1) + 0, (byte) (0)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) (arg3 + 36)); + break label_3; + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local5 + 12)); + callArgs_5[2] = ((long) arg1); + callArgs_5[1] = ((long) (local5 + 8)); + callArgs_5[0] = ((long) arg2); + instance.getMachine().call(569, callArgs_5); + } + instance.global(0).setValue(((long) (local5 + 176))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_566(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_566(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_567(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_1 = 0; + int _snap_0 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_2; + } + label_3: { + label_4: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) : (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 4)) != 0) { + break label_2; + } + local6 = (local4 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local5) != 0) { + break label_3; + } + label_5: { + label_6: { + label_7: { + local7 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(95, local7) != 0) { + break label_7; + } + local4 = (local4 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local7 + 43169) < 0 ? (local7 + 43169) : (local7 + 43169) + 0) & 0xFF) & 4)) != 0) { + break label_5; + } + local4 = local6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break label_2; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(46, ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF)) != 0) { + break label_3; + } + local6 = (local4 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + arg2 = 57; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local5) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) : (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 4)) != 0) { + break label_3; + } + label_8: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) : (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 4)) != 0) { + break label_2; + } + local4 = (local6 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + local7 = 0; + label_9: { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_10; + } + label_11: { + local7 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(95, local7) != 0) { + break label_11; + } + local4 = (local6 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + break label_9; + } + local7 = (local7 + 1); + } + if ((((int) memory.read((int) (local7 + 43168) < 0 ? (local7 + 43168) : (local7 + 43168) + 0) & 0xFF) & 4) != 0) { + break label_9; + } + local6 = local4; + break label_3; + } + local6 = local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_2; + } + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local5) != 0) { + break label_12; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(112, ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF)) != 0) { + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(80, ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF)) != 0) { + break label_12; + } + } + local4 = (local6 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_14; + } + label_15: { + switch((((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + -43)) { + case 0: + { + break label_15; + } + case 1: + { + break label_14; + } + case 2: + { + break label_15; + } + default: + { + break label_14; + } + } + } + local4 = (local6 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_2; + } + label_16: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) : (((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) + 43169) + 0) & 0xFF) & 8)) != 0) { + break label_2; + } + local6 = (local4 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + local7 = 0; + label_17: { + label_18: { + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local5) != 0) { + break label_19; + } + label_20: { + local7 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(95, local7) != 0) { + break label_20; + } + local4 = (local4 + 2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local4); + break label_18; + } + local7 = (local7 + 1); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local7 + 43168) < 0 ? (local7 + 43168) : (local7 + 43168) + 0) & 0xFF) & 8)) != 0) { + break label_17; + } + local4 = local6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + break label_2; + } + break; + } + arg2 = 57; + } + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, local5) != 0) { + break label_21; + } + local4 = 0; + label_22: { + label_23: while (true) { + label_24: { + label_25: { + local7 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (local7 + 43169) < 0 ? (local7 + 43169) : (local7 + 43169) + 0) & 0xFF) & 1)) != 0) { + break label_25; + } + local6 = (local6 + 1); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local6); + local4 = (local4 != 0 ? local4 : 2); + break label_24; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, local7) != 0) { + break label_22; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (local3 + 56)); + instance.getMachine().call(558, callArgs_0); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local4 = 1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break label_2; + } + } + if (local4 != 0) { + break label_2; + } + } + local7 = (arg1 + 4); + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(57, arg2) != 0) { + break label_26; + } + arg2 = ((local3 + 56) + 8); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local8 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local9 = (local4 - local8); + memory.writeI32((int) (local3 + 68) < 0 ? (local3 + 68) : (local3 + 68) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local9, 0) != 0 ? local9 : 0) + 1)); + local8 = (local6 - local8); + local8 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local8, 0) != 0 ? local8 : 0) + 1); + memory.writeI32((int) ((local3 + 56) + 16) < 0 ? ((local3 + 56) + 16) : ((local3 + 56) + 16) + 0, (int) local8); + local9 = memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0); + local10 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + arg1 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) local8); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 60, (int) (local8 != 0 ? local9 : arg1)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) (local8 != 0 ? local10 : local7)); + _snap_0 = local6; + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) & com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local4)); + memory.writeI32((int) ((local3 + 96) + 8) < 0 ? ((local3 + 96) + 8) : ((local3 + 96) + 8) + 0, (int) (local6 != 0 ? (_snap_0 - local4) : 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 56)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 100, (int) (local6 != 0 ? local4 : 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 96, (int) 2); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 96)); + callArgs_1[2] = ((long) 57); + callArgs_1[1] = ((long) (local3 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(543, callArgs_1); + break label_1; + } + local8 = ((local3 + 56) + 8); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + local9 = memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0); + local10 = (local4 - local9); + memory.writeI32((int) (local3 + 68) < 0 ? (local3 + 68) : (local3 + 68) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local10, 0) != 0 ? local10 : 0) + 1)); + local9 = (local6 - local9); + local9 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local9, 0) != 0 ? local9 : 0) + 1); + memory.writeI32((int) ((local3 + 56) + 16) < 0 ? ((local3 + 56) + 16) : ((local3 + 56) + 16) + 0, (int) local9); + local10 = memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0); + local11 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + arg1 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 15) & 0xFF); + memory.writeI32((int) ((local3 + 32) + 16) < 0 ? ((local3 + 32) + 16) : ((local3 + 32) + 16) + 0, (int) local9); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg1), 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 60, (int) (local9 != 0 ? local10 : arg1)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) (local9 != 0 ? local11 : local7)); + _snap_1 = local6; + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) & com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local4)); + memory.writeI32((int) ((local3 + 96) + 8) < 0 ? ((local3 + 96) + 8) : ((local3 + 96) + 8) + 0, (int) (local6 != 0 ? (_snap_1 - local4) : 0)); + memory.writeLong((int) ((local3 + 32) + 8) < 0 ? ((local3 + 32) + 8) : ((local3 + 32) + 8) + 0, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 56)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 100, (int) (local6 != 0 ? local4 : 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 96, (int) 0); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local3 + 96)); + callArgs_2[2] = ((long) arg2); + callArgs_2[1] = ((long) (local3 + 32)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(543, callArgs_2); + break label_1; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(562, callArgs_3); + } + instance.global(0).setValue(((long) (local3 + 112))); + return; + } + + public static long[] call_567(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_567(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_568(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, local3) != 0) { + break label_3; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local5 = 1; + label_4: while (true) { + local6 = local2; + local2 = (local6 + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) local2); + label_5: { + label_6: { + label_7: { + label_8: { + local7 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF); + switch((local7 + -40)) { + case 0: + { + break label_6; + } + case 1: + { + break label_5; + } + case 2: + { + break label_5; + } + case 3: + { + break label_5; + } + case 4: + { + break label_5; + } + case 5: + { + break label_5; + } + case 6: + { + break label_5; + } + case 7: + { + break label_5; + } + case 8: + { + break label_5; + } + case 9: + { + break label_5; + } + case 10: + { + break label_5; + } + case 11: + { + break label_5; + } + case 12: + { + break label_5; + } + case 13: + { + break label_5; + } + case 14: + { + break label_5; + } + case 15: + { + break label_5; + } + case 16: + { + break label_5; + } + case 17: + { + break label_5; + } + case 18: + { + break label_5; + } + case 19: + { + break label_7; + } + default: + { + break label_8; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(10, local7) != 0) { + break label_5; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 28, (int) local2); + local4 = (local4 + 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local4); + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, local3) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(41, ((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF)) != 0) { + break label_5; + } + local2 = (local6 + 2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) local2); + local5 = (local5 + -1); + if (local5 != 0) { + break label_5; + } + local6 = 1; + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, local3) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(59, ((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF)) != 0) { + break label_5; + } + local2 = (local6 + 2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) local2); + local5 = (local5 + 1); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + local3 = ((local1 + 24) + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local4); + local6 = 0; + local7 = memory.readInt((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0); + local4 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32) - local7); + memory.writeI32((int) (local1 + 36) < 0 ? (local1 + 36) : (local1 + 36) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local4, 0) != 0 ? local4 : 0) + 1)); + local2 = (local2 - local7); + local7 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local2, 0) != 0 ? local2 : 0) + 1); + memory.writeI32((int) ((local1 + 24) + 16) < 0 ? ((local1 + 24) + 16) : ((local1 + 24) + 16) + 0, (int) local7); + local4 = memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15) & 0xFF); + memory.writeI32((int) (local1 + 16) < 0 ? (local1 + 16) : (local1 + 16) + 0, (int) local7); + memory.writeLong((int) (local1 + 8) < 0 ? (local1 + 8) : (local1 + 8) + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 28, (int) (local3 != 0 ? local4 : local2)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 24, (int) (local3 != 0 ? local5 : (arg0 + 4))); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 0, (long) memory.readLong((int) local1 < 0 ? local1 : local1 + 24)); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 6892); + callArgs_0[1] = ((long) local1); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(566, callArgs_0); + } + instance.global(0).setValue(((long) (local1 + 48))); + return local6; + } + + public static long[] call_568(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_568(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_569(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local4), 36); + local6 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 119304648) != 0) { + break label_4; + } + label_5: { + label_6: { + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local4), 36); + local7 = (local4 << 1); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, local6) != 0 ? local7 : local6) : 119304647); + if (local7 != 0) { + break label_6; + } + local4 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 119304648) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local7 * 36)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + } + local8 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local8); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local6 = ((int) callResult_1[0]); + arg3 = (local4 + (local5 * 36)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 4, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (arg3 + 12) < 0 ? (arg3 + 12) : (arg3 + 12) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) (arg3 + 20) < 0 ? (arg3 + 20) : (arg3 + 20) + 0, (int) memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 2147483632) != 0) { + break label_4; + } + local7 = (local7 * 36); + arg2 = (arg3 + 24); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 10) != 0) { + break label_8; + } + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 35, (byte) (local6)); + break label_7; + } + local9 = ((local6 | 15) + 1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local9); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + local5 = (local4 + (local5 * 36)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) (local9 | -2147483648)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg1); + memory.writeI32((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (int) local6); + arg2 = arg1; + } + arg1 = (local4 + local7); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local6); + callArgs_3[1] = ((long) local8); + callArgs_3[0] = ((long) arg2); + long[] callResult_3 = instance.getMachine().call(1891, callArgs_3); + memory.writeByte((int) (((int) callResult_3[0]) + local6) < 0 ? (((int) callResult_3[0]) + local6) : (((int) callResult_3[0]) + local6) + 0, (byte) (0)); + local8 = (arg3 + 36); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local4) != 0) { + break label_2; + } + label_9: while (true) { + arg2 = (arg3 + -36); + local6 = (local4 + -36); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (long) memory.readLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + arg3 = (arg3 + -12); + local4 = (local4 + -12); + local7 = (local4 + 8); + memory.writeI32((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 0); + local4 = local6; + arg3 = arg2; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_1; + } + local6 = (local6 + -12); + label_10: while (true) { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local6 + 11) < 0 ? (local6 + 11) : (local6 + 11) + 0), -1) != 0) { + break label_11; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + instance.getMachine().call(1777, callArgs_4); + } + arg2 = (local6 + -24); + local6 = (local6 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg3); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_12; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_7); + } + return; + } + + public static long[] call_569(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_569(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_570(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[17]; + iL[0] = arg0; + iL[1] = arg1; + iL[3] = 0; + label_1: { + if (((int) memory.read((int) 0 < 0 ? 0 : 0 + 657680) & 0xFF) != 0) { + break label_1; + } + memory.writeLong((int) 0 < 0 ? 0 : 0 + 657668, (long) 1348619731073L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657664, (int) 27728); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657616, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657584, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657488, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657472, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656608, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656576, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656528, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656320, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656304, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656208, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656192, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656048, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 656000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655920, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655824, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655808, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655776, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655760, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655664, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655616, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655584, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655488, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655472, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655360, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 655348, (long) 1576252997699L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655344, (int) 9769); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655328, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 655316, (long) 1584842932291L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655312, (int) 4484); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655248, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 655236, (long) 2052994367548L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655232, (int) 17547); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 655008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654960, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654948, (long) 1468878815299L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654944, (int) 9047); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654928, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654916, (long) 1374389534787L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654912, (int) 9496); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654896, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654884, (long) 1378684502083L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654880, (int) 4219); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654800, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654788, (long) 2044404432962L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654784, (int) 28113); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654624, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654612, (long) 1443109011585L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654608, (int) 9821); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654592, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654580, (long) 1447403978881L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654576, (int) 4536); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654560, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654548, (long) 1945620185217L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654544, (int) 9976); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654528, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654516, (long) 1949915152513L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654512, (int) 4669); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654448, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654436, (long) 773094113362L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654432, (int) 28154); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654388, (int) 9); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654384, (int) 17332); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654320, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654304, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654224, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654212, (long) 1494648619137L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654208, (int) 9795); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654192, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 654180, (long) 1503238553729L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654176, (int) 4510); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654048, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 654000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653920, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653824, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653808, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653776, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 653764, (long) 2040109465662L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653760, (int) 1275); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653664, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653616, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653584, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653520, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 653508, (long) 2147483648063L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653504, (int) 26557); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 653492, (long) 2151778615359L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653488, (int) 26538); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653472, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 653008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652916, (int) 5); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652912, (int) 17900); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652688, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 652676, (long) 781684047954L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652672, (int) 28134); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652608, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652576, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652528, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652320, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652304, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652208, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652192, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652048, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 652036, (long) 2048699400258L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652032, (int) 27768); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 652000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651952, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 651940, (long) 1090921693264L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651936, (int) 11807); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651920, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651824, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651808, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651776, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651760, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651664, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651616, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651584, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651488, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 651476, (long) 1133871366224L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651472, (int) 11798); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651456, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 651444, (long) 1370094567553L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651440, (int) 13789); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651316, (int) 4); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651312, (int) 12296); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 651008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650992, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 650980, (long) 1477468749953L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650976, (int) 13775); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650836, (int) 3); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650832, (int) 12314); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650608, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650576, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650528, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650320, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650304, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650208, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650192, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650048, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 650000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649920, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649824, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649808, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649776, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649760, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649664, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649632, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 649620, (long) 1778116460611L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649616, (int) 10074); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649600, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 649588, (long) 1786706395203L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649584, (int) 4767); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649488, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 649476, (long) 768799146066L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649472, (int) 28174); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649072, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 649060, (long) 425201762371L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649056, (int) 26652); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 649044, (long) 502511173699L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649040, (int) 26616); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 649008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648960, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 648948, (long) 597000454211L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648944, (int) 26660); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 648932, (long) 657129996355L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648928, (int) 26624); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648832, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 648820, (long) 1292785156220L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648816, (int) 7392); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648660, (int) 8); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648656, (int) 11935); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648624, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 648616, (long) -34L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648612, (int) 2); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648608, (int) 1310); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648576, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648528, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648496, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 648484, (long) 1709396983937L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648480, (int) 10100); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648464, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 648452, (long) 1717986918529L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648448, (int) 4793); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648320, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648304, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 648292, (long) 1748051689539L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648288, (int) 11848); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648208, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648192, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 648180, (long) 1245540515920L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648176, (int) 11857); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648048, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 648000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647920, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647824, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647808, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 647796, (long) 1700807049345L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647792, (int) 13817); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647776, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 647764, (long) 884763263072L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647760, (int) 1248); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647712, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 647700, (long) 1571958030403L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647696, (int) 9719); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647680, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 647668, (long) 1580547964995L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647664, (int) 4434); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647632, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 647620, (long) 1481763717187L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647616, (int) 9955); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647600, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 647588, (long) 1486058684483L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647584, (int) 4648); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647488, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647472, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 647008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646608, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646576, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 646564, (long) 1490353651841L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646560, (int) 9744); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646544, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 646532, (long) 1498943586433L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646528, (int) 4459); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646336, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 646324, (long) 777389080658L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646320, (int) 27822); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646304, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646208, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646192, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646064, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 646052, (long) 2031519531075L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646048, (int) 9851); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 646000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645920, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645824, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645812, (long) 2027224563779L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645808, (int) 9131); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645776, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645760, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645664, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645632, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645620, (long) 1352914698369L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645616, (int) 8801); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645584, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645572, (long) 1408749273155L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645568, (int) 26586); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645556, (long) 618475290691L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645552, (int) 12925); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645540, (long) 678604832835L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645536, (int) 12912); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645504, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645492, (long) 1670742278211L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645488, (int) 9517); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645472, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645460, (long) 1679332212803L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645456, (int) 4240); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645280, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645268, (long) 1928440316033L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645264, (int) 10052); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645248, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645236, (long) 1932735283329L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645232, (int) 4745); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645188, (int) 38); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645184, (int) 14880); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645168, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645156, (long) 1460288880769L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645152, (int) 8791); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645120, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 645108, (long) 1533303324739L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645104, (int) 26576); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 645008, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644996, (long) 605590388803L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644992, (int) 2830); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644980, (long) 665719930947L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644976, (int) 2812); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644704, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644692, (long) 1000727380035L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644688, (int) 17011); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644624, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644612, (long) 682899800146L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644608, (int) 27809); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644576, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644564, (long) 785979015250L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644560, (int) 27789); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644544, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644532, (long) 1675037245507L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644528, (int) 9585); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644512, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644500, (long) 1683627180099L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644496, (int) 4290); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644368, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644356, (long) 1606317768833L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644352, (int) 9542); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644336, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644324, (long) 1614907703425L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644320, (int) 4265); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644304, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644240, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644228, (long) 1773821493315L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644224, (int) 10002); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644212, (long) 1954210119747L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644208, (int) 16989); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 644196, (long) 1782411427907L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644192, (int) 4695); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644048, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 644000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643920, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643908, (long) 897648164949L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643904, (int) 11891); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643844, (int) 6); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643840, (int) 18871); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643824, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643808, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643796, (long) 1451698946177L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643792, (int) 9637); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643776, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643764, (long) 1455993913473L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643760, (int) 4342); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643728, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643716, (long) 996432412787L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643712, (int) 17198); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643680, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643668, (long) 1305670058097L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643664, (int) 16614); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643616, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643600, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643588, (long) 1915555414083L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643584, (int) 2475); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643488, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643472, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643408, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643396, (long) 1610612736129L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643392, (int) 9611); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643376, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643364, (long) 1619202670721L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643360, (int) 4316); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643344, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643332, (long) 730144440402L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643328, (int) 10320); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643316, (long) 751619276882L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643312, (int) 10302); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643280, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643268, (long) 734439407698L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643264, (int) 5013); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643252, (long) 755914244178L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643248, (int) 4995); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643168, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643156, (long) 974957576283L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643152, (int) 7530); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630976, (int) 3099); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630980, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630984, (int) 525); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630992, (int) 3121); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630996, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631000, (int) 523); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631024, (int) 4947); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631028, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631032, (int) 169); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631040, (int) 4963); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631044, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631048, (int) 163); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631072, (int) 13128); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631076, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631080, (int) 441); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631088, (int) 10254); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631092, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631096, (int) 168); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631104, (int) 10270); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631108, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631112, (int) 162); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631120, (int) 13223); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631124, (int) 104); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631128, (int) 217); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631136, (int) 27638); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631140, (int) 137); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 631144, (long) -5L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631184, (int) 13118); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631188, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631192, (int) 406); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631200, (int) 5140); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631204, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631208, (int) 45); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631264, (int) 10442); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631268, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631272, (int) 44); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631344, (int) 26485); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631348, (int) 34); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631472, (int) 17400); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631476, (int) 27); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631488, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631568, (int) 4372); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631572, (int) 61); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631576, (int) 483); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631584, (int) 4391); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631588, (int) 61); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631592, (int) 481); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631616, (int) 16544); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631620, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631624, (int) 253); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631664, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631728, (int) 16525); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631732, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631736, (int) 249); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631760, (int) 15552); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631764, (int) 41); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631776, (int) 14020); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631780, (int) 68); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631784, (int) 2); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631808, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631824, (int) 3356); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631828, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631832, (int) 128); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631840, (int) 3378); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631844, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631848, (int) 110); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631856, (int) 9191); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631860, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631864, (int) 127); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631872, (int) 9213); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631876, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631880, (int) 109); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631888, (int) 3212); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631892, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631896, (int) 518); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631904, (int) 3233); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631908, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631912, (int) 516); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631920, (int) 27558); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631924, (int) 52); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 631984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632048, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632128, (int) 3344); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632132, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632136, (int) 380); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632144, (int) 3438); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632148, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632152, (int) 385); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632160, (int) 9179); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632164, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632168, (int) 379); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632176, (int) 9247); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632180, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632184, (int) 384); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632192, (int) 11510); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632196, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632200, (int) 299); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632208, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632224, (int) 5733); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632228, (int) 37); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632272, (int) 7295); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632276, (int) 36); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632304, (int) 16363); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632308, (int) 50); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632320, (int) 1118); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632324, (int) 127); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632328, (int) 6); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632432, (int) 13256); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632436, (int) 118); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632440, (int) 215); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632464, (int) 7482); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632468, (int) 124); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632472, (int) 467); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632480, (int) 15256); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632484, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632488, (int) 395); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632528, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632576, (int) 3814); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632580, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632584, (int) 273); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632592, (int) 10427); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632596, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632600, (int) 188); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632608, (int) 3763); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632612, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632616, (int) 271); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632640, (int) 9383); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632644, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632648, (int) 272); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632656, (int) 13313); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632660, (int) 77); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632664, (int) 22); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632672, (int) 9321); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632676, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632680, (int) 270); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632688, (int) 4843); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632692, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632696, (int) 457); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632704, (int) 2984); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632708, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632712, (int) 269); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632736, (int) 2933); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632740, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632744, (int) 267); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632752, (int) 10150); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632756, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632760, (int) 456); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632768, (int) 8985); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632772, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632776, (int) 268); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632800, (int) 8923); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632804, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632808, (int) 266); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632848, (int) 27842); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632852, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632856, (int) 174); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632880, (int) 2540); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632884, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632888, (int) 444); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632912, (int) 7620); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632916, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632920, (int) 238); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632928, (int) 15664); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632932, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632936, (int) 230); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632944, (int) 5740); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632948, (int) 28); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632992, (int) 7371); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 632996, (int) 107); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633000, (int) 19); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633024, (int) 7608); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633028, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633032, (int) 236); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633040, (int) 3825); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633044, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633048, (int) 263); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633056, (int) 14722); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633060, (int) 70); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633064, (int) 13); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633072, (int) 3774); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633076, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633080, (int) 261); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633104, (int) 9394); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633108, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633112, (int) 262); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633136, (int) 9332); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633140, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633144, (int) 260); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633168, (int) 2995); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633172, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633176, (int) 259); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633184, (int) 6092); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633188, (int) 26); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633200, (int) 2944); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633204, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633208, (int) 257); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633232, (int) 8996); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633236, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633240, (int) 258); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633264, (int) 8934); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633268, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633272, (int) 256); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633360, (int) 26246); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633364, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633368, (int) 219); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633376, (int) 16430); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633380, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633384, (int) 252); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633424, (int) 14618); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633428, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633432, (int) 341); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633456, (int) 16701); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633460, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633464, (int) 265); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633472, (int) 5031); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633476, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633480, (int) 165); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633488, (int) 16411); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633492, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633496, (int) 248); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633504, (int) 10338); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633508, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633512, (int) 164); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633552, (int) 5973); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633556, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633560, (int) 151); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633568, (int) 5993); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633572, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633576, (int) 137); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633584, (int) 4204); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633588, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633592, (int) 221); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633616, (int) 9481); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633620, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633624, (int) 220); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633632, (int) 16580); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633636, (int) 113); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633640, (int) 303); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633648, (int) 14562); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633652, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633656, (int) 529); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633664, (int) 14582); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633668, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633672, (int) 528); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633728, (int) 28107); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633732, (int) 56); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633760, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633776, (int) 7513); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633780, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633784, (int) 226); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633808, (int) 6130); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633812, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633816, (int) 296); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633824, (int) 16631); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633828, (int) 114); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633832, (int) 310); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633840, (int) 28101); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633844, (int) 54); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633856, (int) 5962); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633860, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633864, (int) 427); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633888, (int) 14628); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633892, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633896, (int) 316); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633920, (int) 16710); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633924, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633928, (int) 255); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633936, (int) 11901); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633940, (int) 83); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633944, (int) 205); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 633984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634048, (int) 27698); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634052, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634056, (int) 53); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634064, (int) 27710); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634068, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634072, (int) 51); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634096, (int) 14829); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634100, (int) 137); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 634104, (long) -16L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634112, (int) 26122); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634116, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634120, (int) 354); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634176, (int) 5790); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634180, (int) 81); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634184, (int) 231); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634192, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634208, (int) 11399); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634212, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634216, (int) 300); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634304, (int) 12848); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634308, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634312, (int) 470); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634320, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634336, (int) 26026); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634340, (int) 124); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634344, (int) 463); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634368, (int) 13072); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634372, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634376, (int) 360); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634400, (int) 4566); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634404, (int) 61); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634408, (int) 484); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634416, (int) 4586); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634420, (int) 61); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634424, (int) 482); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634480, (int) 14289); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634484, (int) 76); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634488, (int) 7); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634528, (int) 13412); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634532, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634536, (int) 401); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634576, (int) 26132); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634580, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634584, (int) 325); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634608, (int) 17827); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634612, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634616, (int) 297); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634688, (int) 27650); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634692, (int) 51); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634736, (int) 13034); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634740, (int) 18); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634768, (int) 14819); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634772, (int) 137); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 634776, (long) -17L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634816, (int) 6118); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634820, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634824, (int) 298); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634864, (int) 4135); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634868, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634872, (int) 505); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634880, (int) 4158); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634884, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634888, (int) 503); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634912, (int) 16449); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634916, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634920, (int) 245); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634960, (int) 11452); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634964, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634968, (int) 422); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 634992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635008, (int) 4979); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635012, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635016, (int) 225); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635024, (int) 26065); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635028, (int) 124); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635032, (int) 462); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635072, (int) 10286); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635076, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635080, (int) 224); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635344, (int) 7378); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635348, (int) 74); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635352, (int) 17); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635376, (int) 16468); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635380, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635384, (int) 242); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635472, (int) 12884); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635476, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635480, (int) 443); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635488, (int) 3254); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635492, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635496, (int) 519); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635504, (int) 3276); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635508, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635512, (int) 517); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635584, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635616, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635648, (int) 7407); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635652, (int) 124); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635656, (int) 465); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635664, (int) 15211); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635668, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635672, (int) 343); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635712, (int) 11547); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635716, (int) 1); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635728, (int) 14909); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635732, (int) 100); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635736, (int) 55); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635744, (int) 2504); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635748, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635752, (int) 471); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635760, (int) 4022); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635764, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635768, (int) 498); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635776, (int) 4045); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635780, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635784, (int) 496); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635792, (int) 3603); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635796, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635800, (int) 532); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635808, (int) 3626); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635812, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635816, (int) 530); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635824, (int) 3067); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635828, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635832, (int) 359); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635888, (int) 9099); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635892, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635896, (int) 358); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635920, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635952, (int) 3909); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635956, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635960, (int) 512); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635968, (int) 3932); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635972, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635976, (int) 510); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635984, (int) 9567); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635988, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 635992, (int) 388); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636016, (int) 3576); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636020, (int) 64); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636024, (int) 541); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636048, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636112, (int) 7432); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636116, (int) 124); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636120, (int) 464); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636128, (int) 15226); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636132, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636136, (int) 318); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636192, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636208, (int) 6106); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636212, (int) 46); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636240, (int) 8831); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636244, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636248, (int) 145); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636256, (int) 8859); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636260, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636264, (int) 131); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636288, (int) 3083); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636292, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636296, (int) 330); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636304, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636320, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636352, (int) 9115); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636356, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636360, (int) 329); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636368, (int) 16596); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636372, (int) 114); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636376, (int) 308); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636480, (int) 26606); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636484, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636488, (int) 429); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636528, (int) 8821); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636532, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636536, (int) 425); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636560, (int) 7566); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636564, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636568, (int) 228); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636576, (int) 13044); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636580, (int) 39); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636592, (int) 26596); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636596, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636600, (int) 382); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636608, (int) 2802); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636612, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636616, (int) 431); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636624, (int) 12143); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636628, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636632, (int) 311); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636640, (int) 8811); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636644, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636648, (int) 370); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636656, (int) 17262); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636660, (int) 71); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636664, (int) 14); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636720, (int) 3035); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636724, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636728, (int) 356); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636784, (int) 9067); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636788, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636792, (int) 355); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636816, (int) 12808); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636820, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636824, (int) 434); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636832, (int) 1210); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636836, (int) 11); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636944, (int) 4907); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636948, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636952, (int) 203); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636960, (int) 4927); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636964, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636968, (int) 199); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636976, (int) 3649); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636980, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636984, (int) 533); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636992, (int) 3673); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 636996, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637000, (int) 531); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637008, (int) 10214); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637012, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637016, (int) 202); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637024, (int) 10234); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637028, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637032, (int) 198); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637072, (int) 16684); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637076, (int) 113); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637080, (int) 305); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637184, (int) 3051); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637188, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637192, (int) 327); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637200, (int) 5120); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637204, (int) 61); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637208, (int) 485); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637232, (int) 16563); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637236, (int) 114); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637240, (int) 307); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637248, (int) 9083); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637252, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637256, (int) 326); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637280, (int) 3143); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637284, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637288, (int) 526); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637296, (int) 3166); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637300, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637304, (int) 524); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637328, (int) 13761); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637332, (int) 25); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637344, (int) 2877); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637348, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637352, (int) 364); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637376, (int) 8867); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637380, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637384, (int) 363); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637456, (int) 3366); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637460, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637464, (int) 403); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637472, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637488, (int) 9201); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637492, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637496, (int) 402); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637520, (int) 13244); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637524, (int) 97); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637528, (int) 207); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637584, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637600, (int) 9445); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637604, (int) 124); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637608, (int) 474); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637616, (int) 14870); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637620, (int) 78); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637664, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637680, (int) 1260); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637684, (int) 117); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637688, (int) 210); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637712, (int) 13374); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637716, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637720, (int) 351); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637760, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637776, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637808, (int) 2889); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637812, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637816, (int) 334); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637824, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637840, (int) 8879); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637844, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637848, (int) 333); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637888, (int) 18864); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637892, (int) 45); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637904, (int) 4871); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637908, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637912, (int) 178); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637920, (int) 4889); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637924, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637928, (int) 173); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637968, (int) 10178); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637972, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637976, (int) 177); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637984, (int) 10196); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637988, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 637992, (int) 172); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638048, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638080, (int) 6002); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638084, (int) 21); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638176, (int) 13384); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638180, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638184, (int) 322); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638192, (int) 1196); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638196, (int) 31); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638208, (int) 17350); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638212, (int) 130); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638216, (int) 0); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638240, (int) 7644); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638244, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638248, (int) 239); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638256, (int) 2464); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638260, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638264, (int) 435); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638272, (int) 11978); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638276, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638280, (int) 452); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638304, (int) 12040); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638308, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638312, (int) 451); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638320, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638336, (int) 7343); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638340, (int) 88); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638344, (int) 30); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638352, (int) 7632); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638356, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638360, (int) 237); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638368, (int) 7312); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638372, (int) 89); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638376, (int) 31); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638528, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638576, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638608, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638816, (int) 28190); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638820, (int) 65); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638824, (int) 492); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638864, (int) 14812); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638868, (int) 137); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 638872, (long) -23L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 638992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639152, (int) 7548); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639156, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639160, (int) 229); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639168, (int) 16666); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639172, (int) 114); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639176, (int) 309); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639184, (int) 5982); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639188, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639192, (int) 438); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639200, (int) 2751); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639204, (int) 125); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639208, (int) 8); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639216, (int) 12102); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639220, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639224, (int) 312); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639296, (int) 14847); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639300, (int) 75); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639304, (int) 20); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639344, (int) 7145); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639348, (int) 99); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639352, (int) 204); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639360, (int) 2913); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639364, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639368, (int) 120); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639376, (int) 2923); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639380, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639384, (int) 102); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639392, (int) 8903); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639396, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639400, (int) 119); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639408, (int) 8913); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639412, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639416, (int) 101); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639472, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639488, (int) 1042); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639492, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639496, (int) 72); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639504, (int) 1050); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639508, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639512, (int) 61); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639552, (int) 14837); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639556, (int) 126); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639560, (int) 10); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639584, (int) 3721); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639588, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639592, (int) 244); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639616, (int) 9279); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639620, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639624, (int) 243); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639664, (int) 16649); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639668, (int) 113); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639672, (int) 306); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639680, (int) 3470); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639684, (int) 64); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639688, (int) 539); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639696, (int) 3496); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639700, (int) 64); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639704, (int) 537); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639760, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639776, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639808, (int) 27660); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639812, (int) 65); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639816, (int) 491); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639824, (int) 27679); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639828, (int) 65); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639832, (int) 489); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639872, (int) 17231); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639876, (int) 128); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639880, (int) 26); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639920, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 639984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640016, (int) 15197); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640020, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640024, (int) 302); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640048, (int) 3742); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640052, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640056, (int) 241); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640064, (int) 4819); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640068, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640072, (int) 448); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640080, (int) 9300); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640084, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640088, (int) 240); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640128, (int) 10126); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640132, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640136, (int) 447); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640192, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640208, (int) 11906); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640212, (int) 84); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640216, (int) 23); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640272, (int) 2769); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640276, (int) 120); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640280, (int) 213); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640304, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640320, (int) 2749); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640324, (int) 106); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640328, (int) 9); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640528, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640576, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640608, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640640, (int) 3320); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640644, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640648, (int) 353); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640656, (int) 3414); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640660, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640664, (int) 362); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640672, (int) 9155); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640676, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640680, (int) 352); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640688, (int) 9223); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640692, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640696, (int) 361); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640784, (int) 14516); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640788, (int) 64); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640792, (int) 536); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640800, (int) 14539); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640804, (int) 64); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640808, (int) 535); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640832, (int) 12119); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640836, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640840, (int) 313); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640880, (int) 14856); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640884, (int) 79); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 640992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641104, (int) 3332); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641108, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641112, (int) 324); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641120, (int) 3426); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641124, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641128, (int) 332); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641136, (int) 9167); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641140, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641144, (int) 323); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641152, (int) 9235); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641156, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641160, (int) 331); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641216, (int) 12255); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641220, (int) 7); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641232, (int) 2757); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641236, (int) 98); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641240, (int) 56); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641312, (int) 4091); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641316, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641320, (int) 504); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641328, (int) 4113); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641332, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641336, (int) 502); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641472, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641488, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641520, (int) 3388); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641524, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641528, (int) 365); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641536, (int) 7584); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641540, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641544, (int) 235); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641584, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641600, (int) 4632); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641604, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641608, (int) 223); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641616, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641632, (int) 11916); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641636, (int) 101); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641640, (int) 1); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641664, (int) 9939); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641668, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641672, (int) 222); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641760, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641776, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641808, (int) 26642); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641812, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641816, (int) 440); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641824, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641856, (int) 8849); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641860, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641864, (int) 436); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641920, (int) 26632); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641924, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641928, (int) 405); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641936, (int) 2820); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641940, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641944, (int) 442); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641968, (int) 8839); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641972, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641976, (int) 393); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641984, (int) 3401); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641988, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 641992, (int) 335); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642000, (int) 7596); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642004, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642008, (int) 234); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642048, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642144, (int) 12819); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642148, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642152, (int) 445); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642192, (int) 11911); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642196, (int) 95); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642200, (int) 3); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642208, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642288, (int) 5048); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642292, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642296, (int) 201); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642304, (int) 5068); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642308, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642312, (int) 197); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642320, (int) 11841); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642324, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642328, (int) 89); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642336, (int) 11873); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642340, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642344, (int) 83); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642352, (int) 10355); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642356, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642360, (int) 200); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642368, (int) 10375); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642372, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642376, (int) 196); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642432, (int) 11834); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642436, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642440, (int) 73); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642448, (int) 11866); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642452, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642456, (int) 62); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642464, (int) 13803); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642468, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642472, (int) 373); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642528, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642544, (int) 7060); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642548, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642552, (int) 115); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642560, (int) 7071); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642564, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642568, (int) 97); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642576, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642608, (int) 3522); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642612, (int) 64); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642616, (int) 540); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642624, (int) 3549); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642628, (int) 64); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642632, (int) 538); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642848, (int) 11825); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 642852, (long) 1219770712144L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642960, (int) 11816); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 642964, (long) 1176821039184L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 642992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643056, (int) 4720); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643060, (long) 1713691951233L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643088, (int) 10027); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643092, (long) 1705102016641L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643104, (int) 7047); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 643108, (long) 1361504632961L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 643136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630936, (int) 404); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630932, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630928, (int) 26178); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630920, (int) 142); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630916, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630912, (int) 12894); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630904, (int) 156); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630900, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630896, (int) 12876); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630840, (int) 424); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630836, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630832, (int) 5936); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630824, (int) 439); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630820, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630816, (int) 26188); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630808, (int) 507); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630804, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630800, (int) 17808); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630792, (int) 508); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630788, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630784, (int) 17789); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630740, (int) 35); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630736, (int) 13636); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630696, (int) 527); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630692, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630688, (int) 3189); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630648, (int) 423); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630644, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630640, (int) 26454); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630616, (int) 493); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630612, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630608, (int) 26103); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630600, (int) 494); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630596, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630592, (int) 26084); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630580, (int) 23); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630576, (int) 12348); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630536, (int) 509); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630532, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630528, (int) 3887); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630520, (int) 511); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630516, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630512, (int) 3865); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630424, (int) 469); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630420, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630416, (int) 2486); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630392, (int) 534); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630388, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630384, (int) 3697); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630344, (int) 495); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630340, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630336, (int) 4000); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630328, (int) 497); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630324, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630320, (int) 3978); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 630312, (long) -17L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630308, (int) 139); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630304, (int) 12289); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630280, (int) 408); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630276, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630272, (int) 16751); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630264, (int) 54); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630260, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630256, (int) 28209); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630248, (int) 394); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630244, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630240, (int) 14666); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630208, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630200, (int) 96); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630196, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630192, (int) 1034); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630184, (int) 114); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630180, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630176, (int) 1026); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630168, (int) 291); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630164, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630160, (int) 16760); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630152, (int) 432); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630148, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630144, (int) 12866); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630136, (int) 437); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630132, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630128, (int) 14676); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630056, (int) 95); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630052, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630048, (int) 1066); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630040, (int) 113); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630036, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630032, (int) 1058); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 630000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629992, (int) 134); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629988, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629984, (int) 11464); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629976, (int) 148); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629972, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629968, (int) 11442); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629960, (int) 218); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629956, (int) 103); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629952, (int) 26476); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629920, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629912, (int) 184); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629908, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629904, (int) 9681); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629896, (int) 186); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629892, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629888, (int) 9667); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629844, (int) 12); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629840, (int) 13029); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629824, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629816, (int) 185); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629812, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629808, (int) 9898); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629800, (int) 187); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629796, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629792, (int) 9883); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629776, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629760, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629704, (int) 460); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629700, (int) 124); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629696, (int) 26046); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629684, (int) 22); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629680, (int) 17894); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629664, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629640, (int) 418); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629636, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629632, (int) 11430); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629624, (int) 409); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629620, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629616, (int) 8965); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629592, (int) 410); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629588, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629584, (int) 9027); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629496, (int) 411); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629492, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629488, (int) 9363); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629480, (int) 421); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629476, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629472, (int) 13354); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629464, (int) 412); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629460, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629456, (int) 9425); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629424, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 629416, (long) -23L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629412, (int) 140); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629408, (int) 12251); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629384, (int) 292); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629380, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629376, (int) 7129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629368, (int) 513); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629364, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629360, (int) 3955); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629352, (int) 293); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629348, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629344, (int) 7184); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629288, (int) 479); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629284, (int) 61); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629280, (int) 26230); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629272, (int) 480); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629268, (int) 61); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629264, (int) 26214); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629252, (int) 42); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629248, (int) 11538); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629208, (int) 378); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629204, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629200, (int) 13394); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629176, (int) 499); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629172, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629168, (int) 4068); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629128, (int) 294); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629124, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629120, (int) 17384); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629096, (int) 295); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629092, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629088, (int) 17447); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629048, (int) 143); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629044, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629040, (int) 2550); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629032, (int) 157); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629028, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629024, (int) 2532); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629016, (int) 461); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629012, (int) 124); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 629008, (int) 26006); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628984, (int) 468); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628980, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628976, (int) 12830); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628936, (int) 108); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628932, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628928, (int) 13422); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628920, (int) 126); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628916, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628912, (int) 13404); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628904, (int) 520); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628900, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628896, (int) 3298); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628872, (int) 386); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628868, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628864, (int) 8891); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628840, (int) 387); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628836, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628832, (int) 2901); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628792, (int) 208); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628788, (int) 121); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628784, (int) 7157); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628772, (int) 49); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628768, (int) 12981); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628664, (int) 521); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628660, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628656, (int) 11380); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628648, (int) 522); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628644, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628640, (int) 11361); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628616, (int) 11); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628612, (int) 87); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628608, (int) 17785); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628592, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628584, (int) 103); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628580, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628576, (int) 9269); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628568, (int) 121); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628564, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628560, (int) 9259); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628552, (int) 104); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628548, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628544, (int) 3460); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628536, (int) 122); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628532, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628528, (int) 3450); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628520, (int) 160); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628516, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628512, (int) 10411); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628504, (int) 166); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628500, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628496, (int) 10395); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628488, (int) 38); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628484, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628480, (int) 9926); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628472, (int) 42); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628468, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628464, (int) 9913); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628456, (int) 161); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628452, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628448, (int) 5104); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628440, (int) 167); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628436, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628432, (int) 5088); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628424, (int) 39); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628420, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628416, (int) 4619); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628408, (int) 43); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628404, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628400, (int) 4606); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628392, (int) 488); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628388, (int) 65); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628384, (int) 27582); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628376, (int) 490); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628372, (int) 65); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628368, (int) 27564); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628344, (int) 36); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628340, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628336, (int) 9707); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628328, (int) 40); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628324, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628320, (int) 9695); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628312, (int) 37); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628308, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628304, (int) 4422); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628296, (int) 41); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628292, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628288, (int) 4410); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628280, (int) 506); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628276, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628272, (int) 4181); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628228, (int) 17); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628224, (int) 11671); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 628216, (long) -1L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628212, (int) 137); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628208, (int) 28150); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628196, (int) 24); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628192, (int) 7360); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628168, (int) 246); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628164, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628160, (int) 16373); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628120, (int) 458); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628116, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628112, (int) 12069); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 628104, (long) -3L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628100, (int) 137); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628096, (int) 28186); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628088, (int) 459); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628084, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628080, (int) 12007); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628068, (int) 102); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628064, (int) 12285); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628056, (int) 250); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628052, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628048, (int) 16392); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628020, (int) 20); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628016, (int) 14710); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 628000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627952, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627928, (int) 5); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627924, (int) 86); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627920, (int) 15619); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627880, (int) 18); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627876, (int) 108); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627872, (int) 13284); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627824, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627808, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627792, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627784, (int) 514); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627780, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627776, (int) 11492); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627768, (int) 515); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627764, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627760, (int) 11474); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627716, (int) 40); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627712, (int) 14876); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627664, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627616, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627608, (int) 486); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627604, (int) 65); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627600, (int) 15647); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627592, (int) 487); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627588, (int) 65); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627584, (int) 15630); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627576, (int) 4); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627572, (int) 90); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627568, (int) 14761); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627560, (int) 433); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627556, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627552, (int) 2522); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627504, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627496, (int) 214); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627492, (int) 123); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627488, (int) 14921); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627472, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627248, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627232, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627208, (int) 133); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627204, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627200, (int) 13365); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627192, (int) 147); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627188, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627184, (int) 13345); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627160, (int) 372); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627156, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627152, (int) 15241); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627144, (int) 466); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627140, (int) 124); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627136, (int) 7457); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 627008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626824, (int) 29); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626820, (int) 94); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626816, (int) 17463); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626808, (int) 28); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626804, (int) 93); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626800, (int) 7302); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626784, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626776, (int) 27); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626772, (int) 92); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626768, (int) 7333); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626712, (int) 64); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626708, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626704, (int) 8976); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626696, (int) 75); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626692, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626688, (int) 8956); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626680, (int) 66); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626676, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626672, (int) 9038); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626664, (int) 77); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626660, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626656, (int) 9018); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626648, (int) 65); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626644, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626640, (int) 2975); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626632, (int) 76); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626628, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626624, (int) 2966); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626616, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626612, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626608, (int) 3026); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626600, (int) 78); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626596, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626592, (int) 3017); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626584, (int) 68); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626580, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626576, (int) 9374); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626568, (int) 79); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626564, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626560, (int) 9354); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626552, (int) 70); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626548, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626544, (int) 9436); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626536, (int) 81); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626532, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626528, (int) 9416); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626520, (int) 69); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626516, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626512, (int) 3805); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626504, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626500, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626496, (int) 3796); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626488, (int) 71); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626484, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626480, (int) 3856); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626472, (int) 82); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626468, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626464, (int) 3847); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626408, (int) 247); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626404, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626400, (int) 16487); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626376, (int) 105); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626372, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626368, (int) 17844); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626360, (int) 123); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626356, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626352, (int) 17836); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626320, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626304, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626296, (int) 251); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626292, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626288, (int) 16506); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626216, (int) 32); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626212, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626208, (int) 26274); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626200, (int) 33); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626196, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626192, (int) 26256); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626184, (int) 98); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626180, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626176, (int) 26198); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626168, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626164, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626160, (int) 26162); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626104, (int) 34); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626100, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626096, (int) 26283); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626088, (int) 35); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626084, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626080, (int) 26265); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626072, (int) 138); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626068, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626064, (int) 26206); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626056, (int) 152); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626052, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626048, (int) 26170); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 626000, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625988, (int) 15); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625984, (int) 15583); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625976, (int) 107); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625972, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625968, (int) 11416); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625960, (int) 125); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625956, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625952, (int) 11408); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625936, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625920, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625892, (int) 29); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625888, (int) 13630); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625864, (int) 383); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625860, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625856, (int) 13082); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625840, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625832, (int) 24); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625828, (int) 110); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625824, (int) 7500); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625808, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625800, (int) 57); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625796, (int) 81); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625792, (int) 5821); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625784, (int) 58); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625780, (int) 81); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625776, (int) 5801); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625760, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625752, (int) 430); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625748, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625744, (int) 13092); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625728, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625688, (int) 59); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625684, (int) 81); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625680, (int) 5831); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625672, (int) 60); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625668, (int) 81); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625664, (int) 5811); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625640, (int) 16); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625636, (int) 73); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625632, (int) 13308); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625616, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625608, (int) 381); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625604, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625600, (int) 26142); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625592, (int) 100); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625588, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625584, (int) 13138); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625576, (int) 118); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625572, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625568, (int) 13102); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625536, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625520, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625512, (int) 420); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625508, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625504, (int) 5910); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625496, (int) 428); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625492, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625488, (int) 26152); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625480, (int) 140); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625476, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625472, (int) 13146); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625464, (int) 154); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625460, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625456, (int) 13110); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625448, (int) 50); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625444, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625440, (int) 27611); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625432, (int) 52); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625428, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625424, (int) 27600); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625376, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625336, (int) 15); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625332, (int) 109); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625328, (int) 12278); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625320, (int) 419); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625316, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625312, (int) 26432); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625280, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625264, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625256, (int) 136); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625252, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625248, (int) 5950); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625240, (int) 150); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625236, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625232, (int) 5924); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625168, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625152, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625136, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625056, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625016, (int) 135); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625012, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625008, (int) 26466); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 625000, (int) 149); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624996, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624992, (int) 26444); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624952, (int) 275); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624948, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624944, (int) 16719); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624920, (int) 371); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624916, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624912, (int) 14638); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624864, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624848, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624840, (int) 285); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624836, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624832, (int) 16728); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624808, (int) 426); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624804, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624800, (int) 14648); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624792, (int) 216); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624788, (int) 105); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624784, (int) 13235); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624752, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624736, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624664, (int) 46); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624660, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624656, (int) 15695); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624648, (int) 47); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624644, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624640, (int) 15675); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624632, (int) 111); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624628, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624624, (int) 13163); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624616, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624612, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624608, (int) 13154); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624600, (int) 112); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624596, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624592, (int) 11329); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624584, (int) 130); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624580, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624576, (int) 11320); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624552, (int) 48); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624548, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624544, (int) 15705); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624536, (int) 49); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624532, (int) 116); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624528, (int) 15685); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624504, (int) 132); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624500, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624496, (int) 14686); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624488, (int) 146); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624484, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624480, (int) 14658); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624452, (int) 14); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624448, (int) 15722); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624440, (int) 63); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624436, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624432, (int) 16769); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624424, (int) 74); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624420, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624416, (int) 16737); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624388, (int) 32); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624384, (int) 17144); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624328, (int) 84); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624324, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624320, (int) 16776); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624312, (int) 90); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624308, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624304, (int) 16744); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624296, (int) 276); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624292, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624288, (int) 8945); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624264, (int) 278); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624260, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624256, (int) 9007); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624232, (int) 277); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624228, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624224, (int) 2955); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624208, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624200, (int) 279); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624196, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624192, (int) 3006); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624168, (int) 280); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624164, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624160, (int) 9343); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624152, (int) 417); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624148, (int) 129); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624144, (int) 13334); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624136, (int) 282); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624132, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624128, (int) 9405); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624104, (int) 281); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624100, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624096, (int) 3785); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624072, (int) 283); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624068, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624064, (int) 3836); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624056, (int) 286); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624052, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624048, (int) 7113); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624040, (int) 212); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624036, (int) 122); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624032, (int) 7323); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624024, (int) 287); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624020, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624016, (int) 7168); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624008, (int) 211); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624004, (int) 119); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 624000, (int) 7354); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623984, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623968, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623960, (int) 106); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623956, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623952, (int) 11525); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623944, (int) 124); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623940, (int) 67); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623936, (int) 11518); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623924, (int) 33); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623920, (int) 5786); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623904, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623888, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623872, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623856, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623840, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 623832, (long) -33L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623828, (int) 47); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623824, (int) 7364); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623808, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623800, (int) 288); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623796, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623792, (int) 17368); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623776, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623768, (int) 289); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623764, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623760, (int) 17431); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623744, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623732, (int) 43); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623728, (int) 7082); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623712, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623696, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623680, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623668, (int) 72); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623664, (int) 17527); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623648, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623632, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623616, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623600, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623584, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623568, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623552, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623544, (int) 85); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623540, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623536, (int) 7138); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623528, (int) 91); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623524, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623520, (int) 7122); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623512, (int) 86); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623508, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623504, (int) 7193); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623496, (int) 92); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623492, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623488, (int) 7177); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 623480, (long) -16L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623476, (int) 138); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623472, (int) 26480); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623456, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623440, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623424, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623408, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623392, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623380, (int) 10); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623376, (int) 15715); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623360, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623344, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623328, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623312, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623296, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623288, (int) 87); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623284, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623280, (int) 17393); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623272, (int) 93); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623268, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623264, (int) 17377); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623256, (int) 88); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623252, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623248, (int) 17456); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623240, (int) 94); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623236, (int) 80); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623232, (int) 17440); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623216, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623200, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623184, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623172, (int) 53); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623168, (int) 27722); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623156, (int) 16); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623152, (int) 12248); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623140, (int) 48); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623136, (int) 17326); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623120, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623104, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623088, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623072, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623060, (int) 55); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623056, (int) 27746); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623040, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623024, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 623008, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622992, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622976, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622960, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622944, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622928, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622912, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622896, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622880, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622864, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 622856, (long) -2L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622852, (int) 137); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622848, (int) 27818); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622832, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622816, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622800, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622788, (int) 13); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622784, (int) 26756); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622768, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622752, (int) 38861); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 622744, (long) -4L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622740, (int) 137); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622736, (int) 27853); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622720, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622704, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622688, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622672, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622656, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622640, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622624, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622608, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622600, (int) 12); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622596, (int) 69); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622592, (int) 11773); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622576, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622560, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622544, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622528, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622512, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622496, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622480, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622464, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622448, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622432, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622416, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622400, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622384, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622368, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622352, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622336, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622320, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622304, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622288, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622272, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622256, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622240, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622224, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622208, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622192, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622176, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622160, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622144, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622128, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622112, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622096, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622080, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622064, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622048, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622032, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622016, (int) 38861); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 622000, (int) 38861); + memory.writeByte((int) 0 < 0 ? 0 : 0 + 657680, (byte) (1)); + } + label_2: { + int _d0 = func_570__h0(iL, memory, instance); + } + return iL[3]; + } + + public static long[] call_570(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_570(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_571(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = 1; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 1) != 0) { + break label_1; + } + arg1 = (arg0 + arg1); + label_2: while (true) { + local2 = 0; + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + local4 = memory.readInt((int) ((local3 << 2) + 43968) < 0 ? ((local3 << 2) + 43968) : ((local3 << 2) + 43968) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((arg0 + local4), arg1) != 0) { + break label_1; + } + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + switch(local4) { + case 0: + { + break label_1; + } + case 1: + { + break label_7; + } + case 2: + { + break label_6; + } + case 3: + { + break label_5; + } + case 4: + { + break label_4; + } + default: + { + break label_3; + } + } + } + arg0 = (arg0 + 1); + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(128, (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF) & 192)) != 0) { + break label_1; + } + arg0 = (arg0 + 2); + break label_3; + } + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(128, (local4 & 192)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(128, ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & -64) & 255)) != 0) { + break label_1; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(224, local3) != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 160) != 0) { + break label_1; + } + } + arg0 = (arg0 + 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(237, local3) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local4, 159) != 0) { + break label_3; + } + break label_1; + } + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 1) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(128, (local4 & 192)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(128, ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 2) & 0xFF) & -64) & 255)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(128, ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 3) & 0xFF) & -64) & 255)) != 0) { + break label_1; + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(240, local3) != 0) { + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 144) != 0) { + break label_1; + } + } + arg0 = (arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(244, local3) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 143) != 0) { + break label_1; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + local2 = 1; + } + return local2; + } + + public static long[] call_571(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_571(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_572(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 45000); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) 0); + return arg0; + } + + public static long[] call_572(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_572(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_573(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 26880); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + label_2: while (true) { + local4 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_3: { + label_4: { + local6 = (int) local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 26795); + callArgs_1[0] = ((long) local5); + instance.getMachine().call(223, callArgs_1); + break label_3; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local3 + 24)); + callArgs_2[0] = ((long) (local3 + 32)); + instance.getMachine().call(38, callArgs_2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 32) : (local3 + 32))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) 11317); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(223, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), -1) != 0) { + break label_3; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + instance.getMachine().call(1777, callArgs_4); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg1) != 0) { + break label_5; + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 0); + callArgs_5[1] = ((long) 31370); + callArgs_5[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_5); + } + arg2 = (arg2 + 8); + arg1 = (arg1 + -1); + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 0); + callArgs_6[1] = ((long) 26819); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_6); + instance.global(0).setValue(((long) (local3 + 48))); + return; + } + + public static long[] call_573(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_573(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_574(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 8) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 31044); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_0); + } + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_2: { + label_3: { + local5 = (int) local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, 0) != 0) { + break label_3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local5); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) 26795); + callArgs_1[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_1); + break label_2; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 24)); + callArgs_2[0] = ((long) (local2 + 32)); + instance.getMachine().call(38, callArgs_2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 32) : (local2 + 32))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) 11317); + callArgs_3[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), -1) != 0) { + break label_2; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + instance.getMachine().call(1777, callArgs_4); + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_4; + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 0); + callArgs_5[1] = ((long) 30613); + callArgs_5[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + + public static long[] call_574(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_574(arg0, arg1, memory, instance); + return null; + } + + public static int func_575(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 8)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_575(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_575(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_576(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 12)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(3))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return; + } + + public static long[] call_576(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_576(arg0, arg1, memory, instance); + return null; + } + + public static int func_577(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 36372); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 16)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_577(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_577(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_578(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 24)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_578(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_578(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_579(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) arg2); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local6, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 16)); + callArgs_2[1] = ((long) 37839); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local6 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local6); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 28); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local6); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) (local4 + 8)); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 48))); + return local5; + } + + public static long[] call_579(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_579(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_580(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + local6 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local6)); + label_1: { + label_2: { + label_3: { + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local7 = (local7 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local7); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local6); + callArgs_2[1] = ((long) 31140); + callArgs_2[0] = ((long) local7); + instance.getMachine().call(223, callArgs_2); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg3); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(573, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) 31128); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_4); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) arg5); + callArgs_5[1] = ((long) arg4); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(573, callArgs_5); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 0); + callArgs_6[1] = ((long) 38759); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_6); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_7 = (int) (memory.readInt((int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0) < 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 0) : memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 44)); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(7))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[6]; + callArgs_7[5] = ((long) arg5); + callArgs_7[4] = ((long) arg4); + callArgs_7[3] = ((long) arg3); + callArgs_7[2] = ((long) arg2); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) local7); + long[] callResult_7 = ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + local7 = ((int) callResult_7[0]); + instance.global(0).setValue(((long) (local6 + 16))); + return local7; + } + + public static long[] call_580(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int result = Wat2WasmMachine.func_580(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_581(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 16)); + callArgs_2[1] = ((long) 31171); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) 26880); + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_3); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_5; + } + local5 = arg3; + local6 = arg2; + label_6: while (true) { + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(574, callArgs_4); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6) != 0) { + break label_7; + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 0); + callArgs_5[1] = ((long) 31370); + callArgs_5[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_5); + } + local5 = (local5 + 12); + local6 = (local6 + -1); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 0); + callArgs_6[1] = ((long) 38130); + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_6); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_7 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 48)); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) arg3); + callArgs_7[2] = ((long) arg2); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) local5); + long[] callResult_7 = ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + local5 = ((int) callResult_7[0]); + instance.global(0).setValue(((long) (local4 + 32))); + return local5; + } + + public static long[] call_581(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_581(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_582(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 32)); + callArgs_2[1] = ((long) 31318); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = (arg2 + 8); + memory.writeI32((int) ((local3 + 16) + 8) < 0 ? ((local3 + 16) + 8) : ((local3 + 16) + 8) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + 16)); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(574, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) 38759); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_4); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local5 = memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 52); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + int ciTableIdx_5 = (int) (local5); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local3); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + local4 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_582(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_582(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_583(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + long local9 = 0L; + local5 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = 27476; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 4) != 0) { + break label_5; + } + local6 = memory.readInt((int) (62256 + (arg2 << 2)) < 0 ? (62256 + (arg2 << 2)) : (62256 + (arg2 << 2)) + 0); + } + local8 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(memory.readLong((int) arg4 < 0 ? arg4 : arg4 + 0), 32L)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) arg1); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 24, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local8, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local5 + 16)); + callArgs_2[1] = ((long) 38657); + callArgs_2[0] = ((long) local7); + instance.getMachine().call(223, callArgs_2); + local8 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 56, (long) local8); + local9 = memory.readLong((int) arg4 < 0 ? arg4 : arg4 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 48, (long) local9); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 68); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) local9); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local8); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) local5); + callArgs_3[3] = ((long) (local5 + 8)); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local6 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local5 + 64))); + return local6; + } + + public static long[] call_583(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_583(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_584(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + long local8 = 0L; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local6)); + label_1: { + label_2: { + label_3: { + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local7 = (local7 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local7); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) arg5); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) arg4); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local6 + 16)); + callArgs_2[1] = ((long) 35220); + callArgs_2[0] = ((long) local7); + instance.getMachine().call(223, callArgs_2); + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 40, (long) local8); + local9 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 32, (long) local9); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0) < 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 0) : memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 72); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 8, (long) local8); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(7))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[6]; + callArgs_3[5] = ((long) arg5); + callArgs_3[4] = ((long) arg4); + callArgs_3[3] = ((long) local6); + callArgs_3[2] = ((long) (local6 + 8)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local7); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local7 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local6 + 48))); + return local7; + } + + public static long[] call_584(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int result = Wat2WasmMachine.func_584(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_585(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + long local8 = 0L; + int local9 = 0; + long local10 = 0L; + long local11 = 0L; + local7 = (((int) instance.global(0).getValue()) - 240); + instance.global(0).setValue(((long) local7)); + local8 = memory.readLong((int) arg6 < 0 ? arg6 : arg6 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg6 < 0 ? arg6 : arg6 + 16) & 0xFF)) != 0) { + break label_2; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 72, (long) memory.readLong((int) arg6 < 0 ? arg6 : arg6 + 8)); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 64, (long) local8); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local7 + 64)); + callArgs_0[2] = ((long) 2838); + callArgs_0[1] = ((long) 100); + callArgs_0[0] = ((long) (local7 + 128)); + long[] callResult_0 = instance.getMachine().call(1865, callArgs_0); + break label_1; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 48, (long) local8); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local7 + 48)); + callArgs_1[2] = ((long) 2863); + callArgs_1[1] = ((long) 100); + callArgs_1[0] = ((long) (local7 + 128)); + long[] callResult_1 = instance.getMachine().call(1865, callArgs_1); + } + label_3: { + label_4: { + label_5: { + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, 143) != 0) { + break label_5; + } + label_6: while (true) { + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) 0); + callArgs_2[3] = ((long) 0); + callArgs_2[2] = ((long) 142); + callArgs_2[1] = ((long) 97152); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_2); + local9 = (local9 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_3; + } + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 0); + callArgs_3[2] = ((long) local9); + callArgs_3[1] = ((long) 97152); + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_3); + } + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg5); + callArgs_4[0] = ((long) (local7 + 112)); + instance.getMachine().call(38, callArgs_4); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 36, (int) arg4); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 40, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local7 < 0 ? local7 : local7 + 123), 0) != 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 112) : (local7 + 112))); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 44, (int) (local7 + 128)); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local7 + 32)); + callArgs_5[1] = ((long) 36952); + callArgs_5[0] = ((long) local9); + instance.getMachine().call(223, callArgs_5); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local7 < 0 ? local7 : local7 + 123), -1) != 0) { + break label_7; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 112)); + instance.getMachine().call(1777, callArgs_6); + } + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 104, (long) local8); + local10 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 96, (long) local10); + local11 = memory.readLong((int) arg5 < 0 ? arg5 : arg5 + 0); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 88, (long) local11); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local9 < 0 ? local9 : local9 + 0) < 0 ? memory.readInt((int) local9 < 0 ? local9 : local9 + 0) : memory.readInt((int) local9 < 0 ? local9 : local9 + 0) + 76); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 24, (long) local8); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 16, (long) local10); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 8, (long) local11); + int ciTableIdx_7 = (int) (arg0); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(9))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[7]; + callArgs_7[6] = ((long) arg6); + callArgs_7[5] = ((long) (local7 + 8)); + callArgs_7[4] = ((long) arg4); + callArgs_7[3] = ((long) (local7 + 16)); + callArgs_7[2] = ((long) (local7 + 24)); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) local9); + long[] callResult_7 = ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + local9 = ((int) callResult_7[0]); + instance.global(0).setValue(((long) (local7 + 240))); + return local9; + } + + public static long[] call_585(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int result = Wat2WasmMachine.func_585(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_586(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + long local8 = 0L; + int local9 = 0; + long local10 = 0L; + local7 = (((int) instance.global(0).getValue()) - 192); + instance.global(0).setValue(((long) local7)); + local8 = memory.readLong((int) arg5 < 0 ? arg5 : arg5 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg5 < 0 ? arg5 : arg5 + 16) & 0xFF)) != 0) { + break label_2; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 56, (long) memory.readLong((int) arg5 < 0 ? arg5 : arg5 + 8)); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 48, (long) local8); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local7 + 48)); + callArgs_0[2] = ((long) 2838); + callArgs_0[1] = ((long) 100); + callArgs_0[0] = ((long) (local7 + 80)); + long[] callResult_0 = instance.getMachine().call(1865, callArgs_0); + break label_1; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 32, (long) local8); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local7 + 32)); + callArgs_1[2] = ((long) 2863); + callArgs_1[1] = ((long) 100); + callArgs_1[0] = ((long) (local7 + 80)); + long[] callResult_1 = instance.getMachine().call(1865, callArgs_1); + } + label_3: { + label_4: { + label_5: { + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, 143) != 0) { + break label_5; + } + label_6: while (true) { + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) 0); + callArgs_2[3] = ((long) 0); + callArgs_2[2] = ((long) 142); + callArgs_2[1] = ((long) 97152); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_2); + local9 = (local9 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_3; + } + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 0); + callArgs_3[2] = ((long) local9); + callArgs_3[1] = ((long) 97152); + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_3); + } + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 20, (int) arg4); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 16, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 24, (int) (local7 + 80)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local7 + 16)); + callArgs_4[1] = ((long) 36871); + callArgs_4[0] = ((long) local9); + instance.getMachine().call(223, callArgs_4); + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 72, (long) local8); + local10 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 64, (long) local10); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local9 < 0 ? local9 : local9 + 0) < 0 ? memory.readInt((int) local9 < 0 ? local9 : local9 + 0) : memory.readInt((int) local9 < 0 ? local9 : local9 + 0) + 80); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) local10); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 8, (long) local8); + int ciTableIdx_5 = (int) (arg0); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(9))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[7]; + callArgs_5[6] = ((long) arg6); + callArgs_5[5] = ((long) arg5); + callArgs_5[4] = ((long) arg4); + callArgs_5[3] = ((long) local7); + callArgs_5[2] = ((long) (local7 + 8)); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) local9); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + local9 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local7 + 192))); + return local9; + } + + public static long[] call_586(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int result = Wat2WasmMachine.func_586(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_587(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + long local11 = 0L; + local7 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local7)); + label_1: { + label_2: { + label_3: { + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local8 = (local8 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local8); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg5); + callArgs_2[0] = ((long) (local7 + 80)); + instance.getMachine().call(38, callArgs_2); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 36, (int) arg4); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 44, (int) (arg6 != 0 ? 15266 : 15624)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 40, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local7 < 0 ? local7 : local7 + 91), 0) != 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 80) : (local7 + 80))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local7 + 32)); + callArgs_3[1] = ((long) 36749); + callArgs_3[0] = ((long) local8); + instance.getMachine().call(223, callArgs_3); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local7 < 0 ? local7 : local7 + 91), -1) != 0) { + break label_5; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 80)); + instance.getMachine().call(1777, callArgs_4); + } + local9 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 72, (long) local9); + local10 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 64, (long) local10); + local11 = memory.readLong((int) arg5 < 0 ? arg5 : arg5 + 0); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 56, (long) local11); + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0) < 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 0) : memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 84); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 24, (long) local9); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 16, (long) local10); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 8, (long) local11); + int ciTableIdx_5 = (int) (arg0); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(9))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[7]; + callArgs_5[6] = ((long) arg6); + callArgs_5[5] = ((long) (local7 + 8)); + callArgs_5[4] = ((long) arg4); + callArgs_5[3] = ((long) (local7 + 16)); + callArgs_5[2] = ((long) (local7 + 24)); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) local8); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + local8 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local7 + 96))); + return local8; + } + + public static long[] call_587(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int result = Wat2WasmMachine.func_587(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_588(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + long local8 = 0L; + long local9 = 0L; + local6 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local6)); + label_1: { + label_2: { + label_3: { + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local7 = (local7 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local7); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) arg5); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) arg4); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local6 + 16)); + callArgs_2[1] = ((long) 35159); + callArgs_2[0] = ((long) local7); + instance.getMachine().call(223, callArgs_2); + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 40, (long) local8); + local9 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 32, (long) local9); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0) < 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 0) : memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 88); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) local9); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 8, (long) local8); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(7))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[6]; + callArgs_3[5] = ((long) arg5); + callArgs_3[4] = ((long) arg4); + callArgs_3[3] = ((long) local6); + callArgs_3[2] = ((long) (local6 + 8)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local7); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local7 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local6 + 48))); + return local7; + } + + public static long[] call_588(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int result = Wat2WasmMachine.func_588(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_589(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + long local5 = 0L; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 208); + instance.global(0).setValue(((long) local4)); + local5 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg3 < 0 ? arg3 : arg3 + 16) & 0xFF)) != 0) { + break label_2; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 56, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 8)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 48, (long) local5); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local4 + 48)); + callArgs_0[2] = ((long) 2838); + callArgs_0[1] = ((long) 100); + callArgs_0[0] = ((long) (local4 + 96)); + long[] callResult_0 = instance.getMachine().call(1865, callArgs_0); + break label_1; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 32, (long) local5); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local4 + 32)); + callArgs_1[2] = ((long) 2863); + callArgs_1[1] = ((long) 100); + callArgs_1[0] = ((long) (local4 + 96)); + long[] callResult_1 = instance.getMachine().call(1865, callArgs_1); + } + label_3: { + label_4: { + label_5: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_5; + } + label_6: while (true) { + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) 0); + callArgs_2[3] = ((long) 0); + callArgs_2[2] = ((long) 142); + callArgs_2[1] = ((long) 97152); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_2); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 0); + callArgs_3[2] = ((long) local6); + callArgs_3[1] = ((long) 97152); + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_3); + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local4 + 80)); + instance.getMachine().call(38, callArgs_4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) arg1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 91), 0) != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 80) : (local4 + 80))); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) (local4 + 96)); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local4 + 16)); + callArgs_5[1] = ((long) 37021); + callArgs_5[0] = ((long) local6); + instance.getMachine().call(223, callArgs_5); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 91), -1) != 0) { + break label_7; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 80)); + instance.getMachine().call(1777, callArgs_6); + } + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 72, (long) local5); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 120); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local5); + int ciTableIdx_7 = (int) (arg0); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) arg3); + callArgs_7[2] = ((long) (local4 + 8)); + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) local6); + long[] callResult_7 = ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + local6 = ((int) callResult_7[0]); + instance.global(0).setValue(((long) (local4 + 208))); + return local6; + } + + public static long[] call_589(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_589(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_590(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + long local5 = 0L; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 16) & 0xFF)) != 0) { + break label_2; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 8)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 32, (long) local5); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local4 + 32)); + callArgs_0[2] = ((long) 2838); + callArgs_0[1] = ((long) 100); + callArgs_0[0] = ((long) (local4 + 48)); + long[] callResult_0 = instance.getMachine().call(1865, callArgs_0); + break label_1; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) local5); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local4 + 16)); + callArgs_1[2] = ((long) 2863); + callArgs_1[1] = ((long) 100); + callArgs_1[0] = ((long) (local4 + 48)); + long[] callResult_1 = instance.getMachine().call(1865, callArgs_1); + } + label_3: { + label_4: { + label_5: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_5; + } + label_6: while (true) { + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) 0); + callArgs_2[3] = ((long) 0); + callArgs_2[2] = ((long) 142); + callArgs_2[1] = ((long) 97152); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_2); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) 0); + callArgs_3[3] = ((long) 0); + callArgs_3[2] = ((long) local6); + callArgs_3[1] = ((long) 97152); + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_3); + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) (local4 + 48)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local4); + callArgs_4[1] = ((long) 36927); + callArgs_4[0] = ((long) local6); + instance.getMachine().call(223, callArgs_4); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 136)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) arg3); + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) local6); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + local6 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local4 + 160))); + return local6; + } + + public static long[] call_590(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_590(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_591(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local4 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local4 + 48)); + instance.getMachine().call(38, callArgs_2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) arg1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) (arg3 != 0 ? 15266 : 15624)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 59), 0) != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 48) : (local4 + 48))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local4 + 16)); + callArgs_3[1] = ((long) 36824); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(223, callArgs_3); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 59), -1) != 0) { + break label_5; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 48)); + instance.getMachine().call(1777, callArgs_4); + } + local6 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local6); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 152); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local6); + int ciTableIdx_5 = (int) (arg0); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) arg3); + callArgs_5[2] = ((long) (local4 + 8)); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) local5); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + local5 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local4 + 64))); + return local5; + } + + public static long[] call_591(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_591(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_592(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local5 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = 27476; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 4) != 0) { + break label_5; + } + local6 = memory.readInt((int) (62256 + (arg2 << 2)) < 0 ? (62256 + (arg2 << 2)) : (62256 + (arg2 << 2)) + 0); + } + local8 = memory.readLong((int) arg4 < 0 ? arg4 : arg4 + 0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) arg1); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local8, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local5 + 16)); + callArgs_2[1] = ((long) 38447); + callArgs_2[0] = ((long) local7); + instance.getMachine().call(223, callArgs_2); + local8 = memory.readLong((int) arg4 < 0 ? arg4 : arg4 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 40, (long) local8); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 180); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local8); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) (local5 + 8)); + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local6 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local5 + 48))); + return local6; + } + + public static long[] call_592(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_592(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_593(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 37232); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 208)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_593(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_593(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_594(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local4 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) (local4 + 48)); + instance.getMachine().call(38, callArgs_2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) arg1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 59), 0) != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 48) : (local4 + 48))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local4 + 16)); + callArgs_3[1] = ((long) 36704); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(223, callArgs_3); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 59), -1) != 0) { + break label_5; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 48)); + instance.getMachine().call(1777, callArgs_4); + } + local6 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local6); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 216); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local6); + int ciTableIdx_5 = (int) (arg0); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local4 + 8)); + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) local5); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + local5 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local4 + 64))); + return local5; + } + + public static long[] call_594(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_594(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_595(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31237); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_5: { + label_6: { + arg1 = (int) local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_6; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) 26795); + callArgs_3[0] = ((long) local3); + instance.getMachine().call(223, callArgs_3); + break label_5; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 56)); + callArgs_4[0] = ((long) (local2 + 64)); + instance.getMachine().call(38, callArgs_4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 75), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 64) : (local2 + 64))); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local2 + 32)); + callArgs_5[1] = ((long) 11317); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(223, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 75), -1) != 0) { + break label_5; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 64)); + instance.getMachine().call(1777, callArgs_6); + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) 38759); + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_7); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 312); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local4); + int ciTableIdx_8 = (int) (arg0); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) (local2 + 8)); + callArgs_8[0] = ((long) local3); + long[] callResult_8 = ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + local3 = ((int) callResult_8[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return local3; + } + + public static long[] call_595(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_595(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_596(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 36542); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 316)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_596(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_596(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_597(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 36563); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 320)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_597(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_597(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_598(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 32)); + callArgs_2[1] = ((long) 26821); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + local5 = arg2; + local6 = arg1; + label_6: while (true) { + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local4 + 16)); + callArgs_3[1] = ((long) 5730); + callArgs_3[0] = ((long) local7); + instance.getMachine().call(223, callArgs_3); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6) != 0) { + break label_7; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) 31370); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_4); + } + local5 = (local5 + 4); + local6 = (local6 + -1); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg3); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local4); + callArgs_5[1] = ((long) 36317); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(223, callArgs_5); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 324)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) arg3); + callArgs_6[2] = ((long) arg2); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) local5); + long[] callResult_6 = ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + local5 = ((int) callResult_6[0]); + instance.global(0).setValue(((long) (local4 + 48))); + return local5; + } + + public static long[] call_598(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_598(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_599(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) arg1); + memory.writeF64((int) local2 < 0 ? local2 : local2 + 0, (double) (double) com.dylibso.chicory.runtime.OpcodeImpl.F32_REINTERPRET_I32(arg1)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 38197); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 372)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_599(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_599(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_600(int arg0, long arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) arg1); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 38134); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 376)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(10))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = arg1; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_600(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int result = Wat2WasmMachine.func_600(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_601(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + local5 = (arg1 + 8); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) local4); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local2 + 16)); + callArgs_2[1] = ((long) 32580); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 380); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local2); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 32))); + return local3; + } + + public static long[] call_601(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_601(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_602(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 38226); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 392)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_602(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_602(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_603(int arg0, long arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) arg1); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 38166); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 396)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(10))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = arg1; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_603(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int result = Wat2WasmMachine.func_603(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_604(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31255); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_5: { + label_6: { + arg1 = (int) local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_6; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) 26795); + callArgs_3[0] = ((long) local3); + instance.getMachine().call(223, callArgs_3); + break label_5; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 56)); + callArgs_4[0] = ((long) (local2 + 64)); + instance.getMachine().call(38, callArgs_4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 75), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 64) : (local2 + 64))); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local2 + 32)); + callArgs_5[1] = ((long) 11317); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(223, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 75), -1) != 0) { + break label_5; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 64)); + instance.getMachine().call(1777, callArgs_6); + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) 38759); + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_7); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 400); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local4); + int ciTableIdx_8 = (int) (arg0); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) (local2 + 8)); + callArgs_8[0] = ((long) local3); + long[] callResult_8 = ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + local3 = ((int) callResult_8[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return local3; + } + + public static long[] call_604(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_604(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_605(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31220); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_5: { + label_6: { + arg1 = (int) local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_6; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) 26795); + callArgs_3[0] = ((long) local3); + instance.getMachine().call(223, callArgs_3); + break label_5; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 56)); + callArgs_4[0] = ((long) (local2 + 64)); + instance.getMachine().call(38, callArgs_4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 75), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 64) : (local2 + 64))); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local2 + 32)); + callArgs_5[1] = ((long) 11317); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(223, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 75), -1) != 0) { + break label_5; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 64)); + instance.getMachine().call(1777, callArgs_6); + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) 38759); + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_7); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 420); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local4); + int ciTableIdx_8 = (int) (arg0); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) (local2 + 8)); + callArgs_8[0] = ((long) local3); + long[] callResult_8 = ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + local3 = ((int) callResult_8[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return local3; + } + + public static long[] call_605(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_605(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_606(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31291); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(573, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) 38759); + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 512)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) local3); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + return ((int) callResult_5[0]); + } + + public static long[] call_606(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_606(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_607(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31204); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_5: { + label_6: { + arg1 = (int) local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_6; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) 26795); + callArgs_3[0] = ((long) local3); + instance.getMachine().call(223, callArgs_3); + break label_5; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 56)); + callArgs_4[0] = ((long) (local2 + 64)); + instance.getMachine().call(38, callArgs_4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 75), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 64) : (local2 + 64))); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local2 + 32)); + callArgs_5[1] = ((long) 11317); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(223, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 75), -1) != 0) { + break label_5; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 64)); + instance.getMachine().call(1777, callArgs_6); + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) 38759); + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_7); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 528); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local4); + int ciTableIdx_8 = (int) (arg0); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) (local2 + 8)); + callArgs_8[0] = ((long) local3); + long[] callResult_8 = ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + local3 = ((int) callResult_8[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return local3; + } + + public static long[] call_607(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_607(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_608(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31270); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 136, (long) local5); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_5: { + label_6: { + arg1 = (int) local5; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_6; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 96, (int) arg1); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 96)); + callArgs_3[1] = ((long) 26795); + callArgs_3[0] = ((long) local4); + instance.getMachine().call(223, callArgs_3); + break label_5; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local3 + 136)); + callArgs_4[0] = ((long) (local3 + 144)); + instance.getMachine().call(38, callArgs_4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 112, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 155), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 144) : (local3 + 144))); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local3 + 112)); + callArgs_5[1] = ((long) 11317); + callArgs_5[0] = ((long) local4); + instance.getMachine().call(223, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 155), -1) != 0) { + break label_5; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 144)); + instance.getMachine().call(1777, callArgs_6); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) - memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)), 12); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 80, (int) arg1); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local3 + 80)); + callArgs_7[1] = ((long) 26862); + callArgs_7[0] = ((long) local4); + instance.getMachine().call(223, callArgs_7); + label_7: { + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local6 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_7; + } + arg1 = (arg1 + -1); + label_8: while (true) { + local7 = memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0); + local8 = memory.readInt((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0); + label_9: { + label_10: { + label_11: { + label_12: { + label_13: { + switch(memory.readInt((int) local4 < 0 ? local4 : local4 + 0)) { + case 0: + { + break label_13; + } + case 1: + { + break label_12; + } + case 2: + { + break label_11; + } + case 3: + { + break label_10; + } + default: + { + break label_9; + } + } + } + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) local8); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (local3 + 16)); + callArgs_8[1] = ((long) 5180); + callArgs_8[0] = ((long) local9); + instance.getMachine().call(223, callArgs_8); + break label_9; + } + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local8); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local3 + 32)); + callArgs_9[1] = ((long) 5192); + callArgs_9[0] = ((long) local9); + instance.getMachine().call(223, callArgs_9); + break label_9; + } + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) local7); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) (local3 + 48)); + callArgs_10[1] = ((long) 5208); + callArgs_10[0] = ((long) local8); + instance.getMachine().call(223, callArgs_10); + break label_9; + } + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 64, (int) local7); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local3 + 64)); + callArgs_11[1] = ((long) 5221); + callArgs_11[0] = ((long) local8); + instance.getMachine().call(223, callArgs_11); + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_14; + } + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) 0); + callArgs_12[1] = ((long) 31370); + callArgs_12[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_12); + } + arg1 = (arg1 + -1); + local4 = (local4 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) 0); + callArgs_13[1] = ((long) 38130); + callArgs_13[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_13); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 128, (long) local5); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg1 = memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 532); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + int ciTableIdx_14 = (int) (arg1); + int ciFuncId_14 = instance.table(0).requiredRef(ciTableIdx_14); + com.dylibso.chicory.runtime.Instance ciRefInstance_14 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_14), instance); + if (!ciRefInstance_14.type(ciRefInstance_14.functionType(ciFuncId_14)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) arg2); + callArgs_14[1] = ((long) (local3 + 8)); + callArgs_14[0] = ((long) local4); + long[] callResult_14 = ciRefInstance_14.getMachine().call(ciFuncId_14, callArgs_14); + local4 = ((int) callResult_14[0]); + instance.global(0).setValue(((long) (local3 + 160))); + return local4; + } + + public static long[] call_608(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_608(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_609(int arg0, int arg1, long arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) arg2); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 33715); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 556)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(11))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = arg2; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_609(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + long arg2 = args[2]; + int result = Wat2WasmMachine.func_609(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_610(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + local6 = (arg2 + 8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) local5); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 16)); + callArgs_2[1] = ((long) 32626); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 560); + memory.writeLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local3); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 32))); + return local4; + } + + public static long[] call_610(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_610(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_611(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) 38018); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 588)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 16))); + return local5; + } + + public static long[] call_611(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_611(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_612(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) (local3 + 32)); + instance.getMachine().call(38, callArgs_2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 32) : (local3 + 32))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) 36660); + callArgs_3[0] = ((long) local4); + instance.getMachine().call(223, callArgs_3); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), -1) != 0) { + break label_5; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + instance.getMachine().call(1777, callArgs_4); + } + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) local5); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 600); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + int ciTableIdx_5 = (int) (arg0); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local3 + 8)); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) local4); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + local4 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_612(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_612(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_613(int arg0, int arg1, int arg2, long arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) 32871); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 644)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(12))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = arg3; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 16))); + return local5; + } + + public static long[] call_613(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + int result = Wat2WasmMachine.func_613(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_614(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) 37175); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 672)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 16))); + return local5; + } + + public static long[] call_614(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_614(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_615(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0), 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local2 + 16)); + callArgs_2[1] = ((long) 38419); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 676); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local4); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 32))); + return local3; + } + + public static long[] call_615(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_615(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_616(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) 37060); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 680)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 16))); + return local5; + } + + public static long[] call_616(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_616(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_617(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 20, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local5, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 16)); + callArgs_2[1] = ((long) 38568); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local5); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 688); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 8)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_617(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_617(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_618(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) 37119); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 692)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 16))); + return local5; + } + + public static long[] call_618(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_618(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_619(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) arg1); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local6, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 16)); + callArgs_2[1] = ((long) 38508); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local6 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local6); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 704); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local6); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) (local4 + 8)); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 48))); + return local5; + } + + public static long[] call_619(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_619(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_620(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg2); + long[] callResult_2 = instance.getMachine().call(80, callArgs_2); + local6 = ((int) callResult_2[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local6); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local4); + callArgs_3[1] = ((long) 37265); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(223, callArgs_3); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 708)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) arg3); + callArgs_4[2] = ((long) arg2); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) local5); + long[] callResult_4 = ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + local5 = ((int) callResult_4[0]); + instance.global(0).setValue(((long) (local4 + 16))); + return local5; + } + + public static long[] call_620(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_620(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_621(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(80, callArgs_2); + local6 = ((int) callResult_2[0]); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) local6); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local7, 32L)); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local4 + 16)); + callArgs_3[1] = ((long) 38609); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(223, callArgs_3); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local7); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 716); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local7); + int ciTableIdx_4 = (int) (arg0); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) (local4 + 8)); + callArgs_4[2] = ((long) arg2); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) local5); + long[] callResult_4 = ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + local5 = ((int) callResult_4[0]); + instance.global(0).setValue(((long) (local4 + 48))); + return local5; + } + + public static long[] call_621(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_621(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_622(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local5); + callArgs_2[1] = ((long) 36398); + callArgs_2[0] = ((long) local6); + instance.getMachine().call(223, callArgs_2); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 744)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) arg4); + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local6 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local5 + 16))); + return local6; + } + + public static long[] call_622(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_622(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_623(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0), 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local2 + 16)); + callArgs_2[1] = ((long) 36613); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 768); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local4); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 32))); + return local3; + } + + public static long[] call_623(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_623(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_624(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) arg2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local5, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 16)); + callArgs_2[1] = ((long) 32775); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local5); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 760); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) (local3 + 8)); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_624(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_624(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_625(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + long local7 = 0L; + local4 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (int) arg3); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local7, 32L)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local6, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 16)); + callArgs_2[1] = ((long) 32816); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local6 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 56, (long) local6); + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 48, (long) local7); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 756); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) local7); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local6); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) local4); + callArgs_3[1] = ((long) (local4 + 8)); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 64))); + return local5; + } + + public static long[] call_625(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_625(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_626(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 36334); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 728)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_626(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_626(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_627(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + local5 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = 27457; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 26) != 0) { + break label_5; + } + local6 = memory.readInt((int) (62288 + (arg1 << 2)) < 0 ? (62288 + (arg1 << 2)) : (62288 + (arg1 << 2)) + 0); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local5); + callArgs_2[1] = ((long) 38075); + callArgs_2[0] = ((long) local7); + instance.getMachine().call(223, callArgs_2); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 732)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) arg4); + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local6 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local5 + 16))); + return local6; + } + + public static long[] call_627(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_627(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_628(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 20, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local5, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 16)); + callArgs_2[1] = ((long) 38380); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local5); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 784); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 8)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_628(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_628(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_629(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local7 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local7)); + label_1: { + label_2: { + label_3: { + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local8 = (local8 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local8); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local9 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 24, (int) arg2); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local9, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local7 + 16)); + callArgs_2[1] = ((long) 32677); + callArgs_2[0] = ((long) local8); + instance.getMachine().call(223, callArgs_2); + local9 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 40, (long) local9); + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0) < 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 0) : memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 812); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 8, (long) local9); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(9))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[7]; + callArgs_3[6] = ((long) arg6); + callArgs_3[5] = ((long) arg5); + callArgs_3[4] = ((long) arg4); + callArgs_3[3] = ((long) (local7 + 8)); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local8); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local8 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local7 + 48))); + return local8; + } + + public static long[] call_629(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int result = Wat2WasmMachine.func_629(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_630(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local5 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg2); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local7, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local5 + 16)); + callArgs_2[1] = ((long) 35863); + callArgs_2[0] = ((long) local6); + instance.getMachine().call(223, callArgs_2); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 40, (long) local7); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 816); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local7); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) arg4); + callArgs_3[3] = ((long) (local5 + 8)); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local6 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local5 + 48))); + return local6; + } + + public static long[] call_630(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_630(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_631(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local5 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg2); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local7, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local5 + 16)); + callArgs_2[1] = ((long) 35915); + callArgs_2[0] = ((long) local6); + instance.getMachine().call(223, callArgs_2); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 40, (long) local7); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 820); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local7); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) arg4); + callArgs_3[3] = ((long) (local5 + 8)); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local6 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local5 + 48))); + return local6; + } + + public static long[] call_631(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_631(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_632(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg2); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) 35823); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 824)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 16))); + return local5; + } + + public static long[] call_632(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_632(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_633(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local5 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg2); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local7, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local5 + 16)); + callArgs_2[1] = ((long) 35965); + callArgs_2[0] = ((long) local6); + instance.getMachine().call(223, callArgs_2); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 40, (long) local7); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 828); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local7); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) arg4); + callArgs_3[3] = ((long) (local5 + 8)); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local6 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local5 + 48))); + return local6; + } + + public static long[] call_633(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_633(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_634(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local5 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg2); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local7, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local5 + 16)); + callArgs_2[1] = ((long) 36012); + callArgs_2[0] = ((long) local6); + instance.getMachine().call(223, callArgs_2); + local7 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 40, (long) local7); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 832); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local7); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) arg4); + callArgs_3[3] = ((long) (local5 + 8)); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local6 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local5 + 48))); + return local6; + } + + public static long[] call_634(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_634(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_635(int arg0, int arg1, int arg2, long arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local5 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) (local5 + 40) < 0 ? (local5 + 40) : (local5 + 40) + 0, (int) arg4); + memory.writeLong((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (long) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) arg1); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 20, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local7, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local5 + 16)); + callArgs_2[1] = ((long) 32715); + callArgs_2[0] = ((long) local6); + instance.getMachine().call(223, callArgs_2); + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 56, (long) local7); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 840); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local7); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(13))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[5]; + callArgs_3[4] = ((long) arg4); + callArgs_3[3] = arg3; + callArgs_3[2] = ((long) (local5 + 8)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local6 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local5 + 64))); + return local6; + } + + public static long[] call_635(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_635(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_636(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 37927); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 848)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_636(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_636(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_637(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) arg2); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local6, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 16)); + callArgs_2[1] = ((long) 36274); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local6 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local6); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 856); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local6); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) (local4 + 8)); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 48))); + return local5; + } + + public static long[] call_637(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_637(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_638(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 36095); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 860)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_638(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_638(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_639(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) arg2); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local5, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 16)); + callArgs_2[1] = ((long) 37314); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local5 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local5); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 884); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local5); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) (local3 + 8)); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_639(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_639(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_640(int arg0, int arg1, int arg2, long arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + local5 = (int) arg3; + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local6 = (local6 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local5); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) 38719); + callArgs_2[0] = ((long) local6); + instance.getMachine().call(223, callArgs_2); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 896)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(12))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = arg3; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local6 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 16))); + return local6; + } + + public static long[] call_640(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + int result = Wat2WasmMachine.func_640(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_641(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) arg3); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_ROTL(local6, 32L)); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 16)); + callArgs_2[1] = ((long) 37878); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local6 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local6); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 796); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local6); + int ciTableIdx_3 = (int) (arg0); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) (local4 + 8)); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 48))); + return local5; + } + + public static long[] call_641(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_641(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_642(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32277); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 20)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_642(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_642(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_643(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32004); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 32)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_643(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_643(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_644(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37722); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 36)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_644(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_644(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_645(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34379); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 40)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_645(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_645(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_646(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32133); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 56)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_646(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_646(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_647(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37408); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 60)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_647(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_647(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_648(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34046); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 64)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_648(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_648(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_649(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31885); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 92)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_649(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_649(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_650(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37542); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 96)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_650(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_650(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_651(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34232); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 100)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_651(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_651(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_652(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 35283); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 104)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_652(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_652(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_653(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31984); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 108)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_653(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_653(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_654(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37745); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 112)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_654(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_654(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_655(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34413); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 116)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_655(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_655(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_656(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32149); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 124)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_656(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_656(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_657(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37358); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 128)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_657(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_657(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_658(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 33958); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 132)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_658(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_658(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_659(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31849); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 140)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_659(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_659(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_660(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37624); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 144)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_660(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_660(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_661(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34324); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 148)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_661(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_661(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_662(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34701); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 156)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_662(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_662(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_663(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34726); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 160)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_663(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_663(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_664(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34934); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 164)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_664(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_664(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_665(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32063); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 168)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_665(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_665(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_666(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37383); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 172)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_666(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_666(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_667(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34002); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 176)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_667(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_667(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_668(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31867); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 184)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_668(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_668(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_669(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37433); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 188)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_669(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_669(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_670(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34913); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 192)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_670(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_670(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_671(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31903); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 196)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_671(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_671(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_672(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37769); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 200)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_672(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_672(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_673(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 33977); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 204)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_673(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_673(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_674(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 33937); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 548)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_674(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_674(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_675(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34302); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 212)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_675(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_675(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_676(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31444); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 220)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_676(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_676(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_677(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 40)); + callArgs_2[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 40)); + callArgs_3[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) arg3); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) 33634); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 280)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[5]; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local5 + 112))); + return arg1; + } + + public static long[] call_677(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_677(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_678(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 40)); + callArgs_2[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 40)); + callArgs_3[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) arg3); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) 32994); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 288)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[5]; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local5 + 112))); + return arg1; + } + + public static long[] call_678(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_678(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_679(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 40)); + callArgs_2[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 40)); + callArgs_3[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) arg3); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) 33314); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 292)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[5]; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local5 + 112))); + return arg1; + } + + public static long[] call_679(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_679(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_680(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 40)); + callArgs_2[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 40)); + callArgs_3[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) arg3); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) 33477); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 284)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[5]; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local5 + 112))); + return arg1; + } + + public static long[] call_680(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_680(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_681(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 40)); + callArgs_2[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 40)); + callArgs_3[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) arg3); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) 33074); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 296)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[5]; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local5 + 112))); + return arg1; + } + + public static long[] call_681(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_681(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_682(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 36474); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 300)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_682(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_682(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_683(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 40)); + callArgs_2[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 40)); + callArgs_3[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) arg3); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) 32911); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 304)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[5]; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local5 + 112))); + return arg1; + } + + public static long[] call_683(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_683(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_684(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 8)); + callArgs_2[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_2); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 16); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 68)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local2); + callArgs_4[1] = ((long) 38279); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 308)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_684(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_684(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_685(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 35658); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 328)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_685(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_685(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_686(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 35525); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 332)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_686(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_686(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_687(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31783); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 336)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_687(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_687(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_688(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 35386); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 340)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_688(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_688(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_689(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31751); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 344)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_689(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_689(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_690(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 8)); + callArgs_2[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_2); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 16); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 68)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local2); + callArgs_4[1] = ((long) 38354); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 348)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_690(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_690(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_691(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 8)); + callArgs_2[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_2); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 16); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 68)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local2); + callArgs_4[1] = ((long) 38328); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 352)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_691(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_691(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_692(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 36586); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 356)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_692(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_692(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_693(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31697); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 360)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_693(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_693(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_694(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31798); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 364)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_694(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_694(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_695(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31829); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 368)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_695(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_695(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_696(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 35768); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 384)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_696(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_696(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_697(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 35713); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 388)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_697(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_697(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_698(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 40)); + callArgs_2[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 40)); + callArgs_3[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) arg3); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) 33559); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 404)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[5]; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local5 + 112))); + return arg1; + } + + public static long[] call_698(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_698(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_699(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 35741); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 408)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_699(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_699(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_700(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 35686); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 412)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_700(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_700(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_701(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 35796); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 416)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_701(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_701(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_702(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 34949); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 424)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_702(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_702(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_703(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34809); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 428)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_703(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_703(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_704(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34829); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 432)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_704(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_704(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_705(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34542); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 436)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_705(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_705(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_706(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 35012); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 440)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_706(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_706(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_707(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34851); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 444)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_707(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_707(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_708(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 35577); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 448)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_708(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_708(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_709(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34789); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 452)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_709(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_709(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_710(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 35414); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 456)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_710(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_710(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_711(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34749); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 464)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_711(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_711(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_712(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34769); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 460)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_712(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_712(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_713(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34564); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 468)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_713(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_713(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_714(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34873); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 472)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_714(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_714(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_715(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 36061); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 476)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_715(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_715(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_716(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34894); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 480)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_716(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_716(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_717(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + long local4 = 0L; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) (local2 + 32)); + instance.getMachine().call(38, callArgs_2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 32) : (local2 + 32))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) 36641); + callArgs_3[0] = ((long) local3); + instance.getMachine().call(223, callArgs_3); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), -1) != 0) { + break label_5; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + instance.getMachine().call(1777, callArgs_4); + } + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 484); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local4); + int ciTableIdx_5 = (int) (arg0); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local2 + 8)); + callArgs_5[0] = ((long) local3); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + local3 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local2 + 48))); + return local3; + } + + public static long[] call_717(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_717(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_718(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31734); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 488)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_718(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_718(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_719(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31709); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 492)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_719(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_719(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_720(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 36516); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 496)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_720(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_720(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_721(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 35624); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 504)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_721(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_721(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_722(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 35467); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 508)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_722(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_722(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_723(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31720); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 500)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_723(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_723(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_724(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 40)); + callArgs_2[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 40)); + callArgs_3[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) arg3); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) 33155); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 572)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[5]; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local5 + 112))); + return arg1; + } + + public static long[] call_724(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_724(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_725(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 40)); + callArgs_2[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 40)); + callArgs_3[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) arg3); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) 33235); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 576)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[5]; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local5 + 112))); + return arg1; + } + + public static long[] call_725(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_725(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_726(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + local5 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 + 40)); + callArgs_2[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local5 + 40)); + callArgs_3[0] = ((long) (local5 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) arg3); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local5); + callArgs_4[1] = ((long) 33401); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 516)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[5]; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local5 + 112))); + return arg1; + } + + public static long[] call_726(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_726(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_727(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 35358); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 520)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_727(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_727(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_728(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31810); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 544)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_728(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_728(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_729(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + label_2: { + label_3: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31767); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 524)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_729(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_729(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_730(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 8)); + callArgs_2[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_2); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 16); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 68)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local2); + callArgs_4[1] = ((long) 38304); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 536)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_730(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_730(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_731(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 8)); + callArgs_2[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_2); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 16); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 68)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local2); + callArgs_4[1] = ((long) 38253); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 540)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_731(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_731(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_732(int arg0, int arg1, int arg2, long arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + local6 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local6 + 40)); + callArgs_2[0] = ((long) (local6 + 48)); + instance.getMachine().call(192, callArgs_2); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local6 + 40)); + callArgs_3[0] = ((long) (local6 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) arg3); + memory.writeLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0, (long) arg4); + memory.writeLong((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0, (long) arg5); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local7); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local6); + callArgs_4[1] = ((long) 33842); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 564)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(15))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[6]; + callArgs_5[5] = arg5; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local6 + 112))); + return arg1; + } + + public static long[] call_732(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_732(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_733(int arg0, int arg1, int arg2, long arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + local6 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 40, (int) arg1); + label_1: { + label_2: { + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + arg1 = (arg1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local6 + 40)); + callArgs_2[0] = ((long) (local6 + 48)); + instance.getMachine().call(192, callArgs_2); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 48); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local6 + 40)); + callArgs_3[0] = ((long) (local6 + 48)); + instance.getMachine().call(192, callArgs_3); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) arg3); + memory.writeLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0, (long) arg4); + memory.writeLong((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0, (long) arg5); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local7); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 100)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local6); + callArgs_4[1] = ((long) 33746); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(223, callArgs_4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 568)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(15))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[6]; + callArgs_5[5] = arg5; + callArgs_5[4] = arg4; + callArgs_5[3] = arg3; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 40)); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg1 = ((int) callResult_5[0]); + instance.global(0).setValue(((long) (local6 + 112))); + return arg1; + } + + public static long[] call_733(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_733(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_734(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32166); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 552)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_734(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_734(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_735(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37601); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 580)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_735(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_735(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_736(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34090); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 584)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_736(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_736(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_737(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34585); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 592)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_737(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_737(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_738(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34615); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 596)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_738(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_738(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_739(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 36179); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 604)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_739(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_739(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_740(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 35067); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 608)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_740(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_740(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_741(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 35114); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 612)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_741(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_741(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_742(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34502); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 616)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_742(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_742(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_743(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32047); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 620)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_743(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_743(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_744(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37816); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 624)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_744(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_744(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_745(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34114); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 628)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_745(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_745(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_746(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local5 = (local5 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) 37960); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(223, callArgs_2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 632)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) arg3); + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local5 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local4 + 16))); + return local5; + } + + public static long[] call_746(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_746(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_747(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34643); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 636)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_747(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_747(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_748(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34673); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 640)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_748(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_748(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_749(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34522); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 648)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_749(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_749(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_750(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32223); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 652)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_750(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_750(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_751(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37457); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 656)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_751(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_751(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_752(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34485); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 660)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_752(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_752(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_753(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31920); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 664)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_753(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_753(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_754(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37518); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 668)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_754(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_754(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_755(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34157); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 684)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_755(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_755(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_756(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34253); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 696)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_756(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_756(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_757(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 36229); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 700)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_757(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_757(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_758(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34396); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 712)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_758(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_758(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_759(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31967); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 720)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_759(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_759(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_760(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37792); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 724)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_760(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_760(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_761(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32182); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 736)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_761(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_761(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_762(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37649); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 740)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_762(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_762(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_763(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34431); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 764)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_763(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_763(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_764(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34021); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 752)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_764(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_764(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_765(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34065); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 748)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_765(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_765(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_766(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32081); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 772)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_766(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_766(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_767(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37485); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 776)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_767(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_767(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_768(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34359); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 780)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_768(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_768(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_769(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 31941); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 788)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_769(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_769(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_770(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37674); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 804)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_770(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_770(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_771(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34283); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 808)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_771(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_771(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_772(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34183); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 836)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_772(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_772(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_773(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34207); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 844)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_773(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_773(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_774(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34138); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 852)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_774(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_774(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_775(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32099); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 864)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_775(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_775(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_776(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37569); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 792)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_776(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_776(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_777(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32022); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 800)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_777(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_777(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_778(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 37700); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 868)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_778(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_778(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_779(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34343); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 872)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_779(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_779(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_780(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 35321); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 876)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_780(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_780(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_781(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32118); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 880)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_781(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_781(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_782(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local3 = (local3 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 34456); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(223, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 888)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local3); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_782(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_782(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_783(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local4 = (local4 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 36131); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(223, callArgs_2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 892)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local4 = ((int) callResult_3[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_783(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_783(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_784(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + -2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 143) != 0) { + break label_3; + } + label_4: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 142); + callArgs_0[1] = ((long) 97152); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_0); + local1 = (local1 + -142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 142) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) 0); + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) local1); + callArgs_1[1] = ((long) 97152); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(224, callArgs_1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 32199); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(223, callArgs_2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 900)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + return ((int) callResult_3[0]); + } + + public static long[] call_784(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_784(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_785(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 224)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_785(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_785(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_786(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 228)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_786(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_786(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_787(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 236)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_787(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_787(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_788(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 240)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_788(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_788(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_789(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 232)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_789(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_789(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_790(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 244)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_790(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_790(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_791(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 248)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_791(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_791(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_792(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 252)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) arg4); + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_792(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_792(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_793(int arg0, long arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 256)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(10))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = arg1; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_793(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int result = Wat2WasmMachine.func_793(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_794(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 260)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_794(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_794(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_795(int arg0, long arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 264)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(10))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = arg1; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_795(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int result = Wat2WasmMachine.func_795(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_796(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 268); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + int ciTableIdx_0 = (int) (local3); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + arg1 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return arg1; + } + + public static long[] call_796(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_796(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_797(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 272); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + int ciTableIdx_0 = (int) (arg0); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + arg1 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return arg1; + } + + public static long[] call_797(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_797(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_798(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) local3); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 276); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) local3); + int ciTableIdx_0 = (int) (arg0); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + arg1 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return arg1; + } + + public static long[] call_798(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_798(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_799(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_799(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_799(arg0, memory, instance); + return null; + } + + public static int func_800(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return arg0; + } + + public static long[] call_800(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_800(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_801(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[25]; + long[] lL = new long[3]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = arg2; + iL[3] = arg3; + iL[4] = (((int) instance.global(0).getValue()) - 3264); + instance.global(0).setValue(((long) iL[4])); + iL[5] = (iL[4] + 2948); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) 0); + memory.writeI32((int) (iL[4] + 2944) < 0 ? (iL[4] + 2944) : (iL[4] + 2944) + 0, (int) iL[1]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2940, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) iL[2]); + callArgs_0[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 20)); + callArgs_0[0] = ((long) (iL[4] + 2952)); + long[] callResult_0 = instance.getMachine().call(572, callArgs_0); + iL[1] = ((int) callResult_0[0]); + memory.writeLong((int) (iL[4] + 2984) < 0 ? (iL[4] + 2984) : (iL[4] + 2984) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 2992) < 0 ? (iL[4] + 2992) : (iL[4] + 2992) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 3000) < 0 ? (iL[4] + 3000) : (iL[4] + 3000) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 3008) < 0 ? (iL[4] + 3008) : (iL[4] + 3008) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 3016) < 0 ? (iL[4] + 3016) : (iL[4] + 3016) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 3024) < 0 ? (iL[4] + 3024) : (iL[4] + 3024) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 3032) < 0 ? (iL[4] + 3032) : (iL[4] + 3032) + 0, (int) 0); + memory.writeLong((int) (iL[4] + 3056) < 0 ? (iL[4] + 3056) : (iL[4] + 3056) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 3064) < 0 ? (iL[4] + 3064) : (iL[4] + 3064) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 3072) < 0 ? (iL[4] + 3072) : (iL[4] + 3072) + 0, (long) 0L); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 2976, (long) 0L); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3048, (long) 0L); + memory.writeShort((int) iL[4] < 0 ? iL[4] : iL[4] + 3044, (short) (0)); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3040, (int) -1); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3036, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3080, (int) -1); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2972, (int) (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 20) != 0 ? iL[1] : iL[2])); + iL[6] = ((iL[4] + 2936) | 4); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(iL[23]), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(iL[24])).typesMatch(instance.type(3))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) iL[6]); + callArgs_1[0] = ((long) iL[2]); + ciRefInstance_1.getMachine().call(iL[24], callArgs_1); + label_1: { + label_2: { + label_3: { + iL[2] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0); + iL[1] = (iL[2] + 4); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[1], iL[0]) != 0) { + break label_3; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 4, (int) 26500); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) 7673); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) iL[4]); + callArgs_2[1] = ((long) 10873); + callArgs_2[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_2); + break label_2; + } + iL[7] = ((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 25) & 0xFF); + iL[5] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[3] = memory.readInt((int) (iL[5] + iL[2]) < 0 ? (iL[5] + iL[2]) : (iL[5] + iL[2]) + 0); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[1]); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1836278016, iL[3]) != 0) { + break label_4; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) 15522); + callArgs_3[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_3); + break label_2; + } + label_5: { + iL[3] = (iL[2] + 6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_5; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 20, (int) 12777); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 16, (int) 7664); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (iL[4] + 16)); + callArgs_4[1] = ((long) 10873); + callArgs_4[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_4); + break label_2; + } + iL[1] = ((int) memory.readShort((int) (iL[5] + iL[1]) < 0 ? (iL[5] + iL[1]) : (iL[5] + iL[1]) + 0) & 0xFFFF); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_6: { + iL[2] = (iL[2] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[2], iL[0]) != 0) { + break label_6; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 36, (int) 11532); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 32, (int) 7664); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (iL[4] + 32)); + callArgs_5[1] = ((long) 10873); + callArgs_5[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_5); + break label_2; + } + iL[3] = ((int) memory.readShort((int) (iL[5] + iL[3]) < 0 ? (iL[5] + iL[3]) : (iL[5] + iL[3]) + 0) & 0xFFFF); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[2]); + label_7: { + label_8: { + label_9: { + label_10: { + switch(iL[3]) { + case 0: + { + break label_10; + } + case 1: + { + break label_9; + } + default: + { + break label_8; + } + } + } + iL[3] = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[1]) != 0) { + break label_7; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2932, (int) 1); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2928, (int) iL[1]); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) (iL[4] + 2928)); + callArgs_6[1] = ((long) 29647); + callArgs_6[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_6); + break label_1; + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) 13172); + callArgs_7[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_7); + break label_2; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 48, (int) iL[3]); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (iL[4] + 48)); + callArgs_8[1] = ((long) 2696); + callArgs_8[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_8); + break label_2; + } + label_11: { + iL[2] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 0) < 0 ? memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 0) : memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 0) + 16)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) 1); + callArgs_9[0] = ((long) iL[2]); + long[] callResult_9 = ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_9[0])) != 0) { + break label_11; + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) 0); + callArgs_10[1] = ((long) 25422); + callArgs_10[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_10); + break label_2; + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3094, (long) 0L); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3088, (long) 0L); + label_12: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2944)) != 0) { + break label_12; + } + label_13: { + label_14: { + label_15: { + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[3], iL[1]) != 0) { + break label_15; + } + iL[8] = (iL[4] + 2976); + iL[9] = (iL[4] + 2988); + iL[10] = (iL[4] + 3000); + iL[11] = (iL[7] & 255); + iL[7] = 0; + iL[5] = 0; + label_16: while (true) { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[2] = ((int) memory.read((int) (iL[0] + iL[3]) < 0 ? (iL[0] + iL[3]) : (iL[0] + iL[3]) + 0) & 0xFF); + iL[3] = (iL[3] + 1); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_17: { + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (iL[4] + 3168)); + callArgs_11[1] = ((long) (iL[0] + iL[1])); + callArgs_11[0] = ((long) (iL[0] + iL[3])); + long[] callResult_11 = instance.getMachine().call(177, callArgs_11); + iL[3] = ((int) callResult_11[0]); + if (iL[3] != 0) { + break label_17; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 64, (int) 15018); + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) (iL[4] + 64)); + callArgs_12[1] = ((long) 11260); + callArgs_12[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_12); + break label_2; + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[3] = (iL[0] + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[3]); + label_18: { + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[2], 14) != 0) { + break label_19; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 96, (int) iL[2]); + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) (iL[4] + 96)); + callArgs_13[1] = ((long) 5649); + callArgs_13[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_13); + if (iL[11] != 0) { + break label_14; + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + iL[7] = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2944)) != 0) { + break label_18; + } + break label_2; + } + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_20; + } + label_21: { + iL[12] = ((iL[4] + 3088) + iL[2]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[12] < 0 ? iL[12] : iL[12] + 0) & 0xFF)) != 0) { + break label_21; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) iL[2]); + long[] callResult_14 = instance.getMachine().call(79, callArgs_14); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2912, (int) ((int) callResult_14[0])); + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) (iL[4] + 2912)); + callArgs_15[1] = ((long) 7960); + callArgs_15[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_15); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + break label_2; + } + memory.writeByte((int) iL[12] < 0 ? iL[12] : iL[12] + 0, (byte) (1)); + } + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2944)) != 0) { + break label_22; + } + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) 0); + callArgs_16[1] = ((long) 17750); + callArgs_16[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_16); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + break label_2; + } + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_23; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3040)) != 0) { + break label_23; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) iL[2]); + long[] callResult_17 = instance.getMachine().call(78, callArgs_17); + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3040)); + long[] callResult_18 = instance.getMachine().call(78, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(((int) callResult_17[0]), ((int) callResult_18[0])) != 0) { + break label_23; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) iL[2]); + long[] callResult_19 = instance.getMachine().call(79, callArgs_19); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2896, (int) ((int) callResult_19[0])); + long[] callArgs_20 = new long[3]; + callArgs_20[2] = ((long) (iL[4] + 2896)); + callArgs_20[1] = ((long) 11678); + callArgs_20[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_20); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + break label_2; + } + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_24; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 3044) & 0xFF) & 255)) != 0) { + break label_24; + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) iL[2]); + long[] callResult_21 = instance.getMachine().call(79, callArgs_21); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2880, (int) ((int) callResult_21[0])); + long[] callArgs_22 = new long[3]; + callArgs_22[2] = ((long) (iL[4] + 2880)); + callArgs_22[1] = ((long) 12598); + callArgs_22[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_22); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + break label_2; + } + label_25: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_23 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 24)); + int ciFuncId_23 = instance.table(0).requiredRef(ciTableIdx_23); + com.dylibso.chicory.runtime.Instance ciRefInstance_23 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_23), instance); + if (!ciRefInstance_23.type(ciRefInstance_23.functionType(ciFuncId_23)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_23 = new long[4]; + callArgs_23[3] = ((long) iL[0]); + callArgs_23[2] = ((long) iL[2]); + callArgs_23[1] = ((long) iL[5]); + callArgs_23[0] = ((long) iL[3]); + long[] callResult_23 = ciRefInstance_23.getMachine().call(ciFuncId_23, callArgs_23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_23[0])) != 0) { + break label_25; + } + long[] callArgs_24 = new long[3]; + callArgs_24[2] = ((long) 0); + callArgs_24[1] = ((long) 23761); + callArgs_24[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_24); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + break label_2; + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036); + iL[13] = ((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 25) & 0xFF); + iL[12] = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[13]); + label_26: { + label_27: { + int _d1 = func_801__h1(iL, lL, memory, instance); + if (_d1 == 1) + break label_14; + if (_d1 == 2) + break label_2; + if (_d1 == 3) + break label_26; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)); + } + label_537: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_537; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3040, (int) iL[2]); + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2944)) != 0) { + break label_13; + } + } + iL[5] = (iL[5] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[3], iL[1]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + break; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 84, (int) 17519); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 80, (int) 7656); + long[] callArgs_613 = new long[3]; + callArgs_613[2] = ((long) (iL[4] + 80)); + callArgs_613[1] = ((long) 10873); + callArgs_613[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_613); + break label_2; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + break label_2; + } + iL[3] = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) != 0) { + break label_1; + } + } + label_538: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3072), memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3068)) != 0) { + break label_538; + } + long[] callArgs_614 = new long[3]; + callArgs_614[2] = ((long) 0); + callArgs_614[1] = ((long) 6164); + callArgs_614[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_614); + break label_2; + } + label_539: { + if (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3076) != 0) { + break label_539; + } + iL[3] = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3080) + 1), 2) != 0) { + break label_539; + } + long[] callArgs_615 = new long[3]; + callArgs_615[2] = ((long) 0); + callArgs_615[1] = ((long) 12160); + callArgs_615[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_615); + break label_1; + } + label_540: { + iL[2] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_616 = (int) (memory.readInt((int) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 0) < 0 ? memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 0) : memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 0) + 20)); + int ciFuncId_616 = instance.table(0).requiredRef(ciTableIdx_616); + com.dylibso.chicory.runtime.Instance ciRefInstance_616 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_616), instance); + if (!ciRefInstance_616.type(ciRefInstance_616.functionType(ciFuncId_616)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_616 = new long[1]; + callArgs_616[0] = ((long) iL[2]); + long[] callResult_616 = ciRefInstance_616.getMachine().call(ciFuncId_616, callArgs_616); + if (((int) callResult_616[0]) != 0) { + break label_540; + } + iL[3] = 0; + break label_1; + } + long[] callArgs_617 = new long[3]; + callArgs_617[2] = ((long) 0); + callArgs_617[1] = ((long) 25450); + callArgs_617[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_617); + } + iL[3] = 1; + } + label_541: { + iL[2] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3024); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_541; + } + memory.writeI32((int) (iL[4] + 3028) < 0 ? (iL[4] + 3028) : (iL[4] + 3028) + 0, (int) iL[2]); + long[] callArgs_618 = new long[1]; + callArgs_618[0] = ((long) iL[2]); + instance.getMachine().call(1777, callArgs_618); + } + label_542: { + iL[2] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3012); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_542; + } + memory.writeI32((int) (iL[4] + 3016) < 0 ? (iL[4] + 3016) : (iL[4] + 3016) + 0, (int) iL[2]); + long[] callArgs_619 = new long[1]; + callArgs_619[0] = ((long) iL[2]); + instance.getMachine().call(1777, callArgs_619); + } + label_543: { + iL[2] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3000); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_543; + } + memory.writeI32((int) (iL[4] + 3004) < 0 ? (iL[4] + 3004) : (iL[4] + 3004) + 0, (int) iL[2]); + long[] callArgs_620 = new long[1]; + callArgs_620[0] = ((long) iL[2]); + instance.getMachine().call(1777, callArgs_620); + } + label_544: { + iL[2] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2988); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_544; + } + memory.writeI32((int) (iL[4] + 2992) < 0 ? (iL[4] + 2992) : (iL[4] + 2992) + 0, (int) iL[2]); + long[] callArgs_621 = new long[1]; + callArgs_621[0] = ((long) iL[2]); + instance.getMachine().call(1777, callArgs_621); + } + label_545: { + iL[2] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2976); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_545; + } + memory.writeI32((int) (iL[4] + 2980) < 0 ? (iL[4] + 2980) : (iL[4] + 2980) + 0, (int) iL[2]); + long[] callArgs_622 = new long[1]; + callArgs_622[0] = ((long) iL[2]); + instance.getMachine().call(1777, callArgs_622); + } + instance.global(0).setValue(((long) (iL[4] + 3264))); + return iL[3]; + } + + public static long[] call_801(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_801(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_802(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 208); + local4 = local3; + instance.global(0).setValue(((long) local3)); + local5 = 1; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 109) & 0xFF)) != 0) { + break label_1; + } + local5 = ((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) + 26) & 0xFF); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 204, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 200, (int) arg2); + local6 = (local4 + 64); + label_2: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 128); + callArgs_0[0] = ((long) (local4 + 64)); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg2 = (((int) callResult_0[0]) + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 129) != 0) { + break label_2; + } + local6 = (local3 - ((arg2 + 15) & -16)); + instance.global(0).setValue(((long) local6)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 200)); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1875, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + arg2 = ((int) callResult_2[0]); + memory.writeI32((int) ((local4 + 24) + 12) < 0 ? ((local4 + 24) + 12) : ((local4 + 24) + 12) + 0, (int) memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 28, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) local5); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 2147483632) != 0) { + break label_3; + } + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 10) != 0) { + break label_5; + } + arg1 = (local4 + 48); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 59, (byte) (arg2)); + break label_4; + } + local3 = ((arg2 | 15) + 1); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg1 = ((int) callResult_3[0]); + memory.writeI32((int) (local4 + 56) < 0 ? (local4 + 56) : (local4 + 56) + 0, (int) (local3 | -2147483648)); + memory.writeI32((int) (local4 + 52) < 0 ? (local4 + 52) : (local4 + 52) + 0, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 48, (int) arg1); + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg2); + callArgs_4[1] = ((long) local6); + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(1890, callArgs_4); + memory.writeByte((int) (((int) callResult_4[0]) + arg2) < 0 ? (((int) callResult_4[0]) + arg2) : (((int) callResult_4[0]) + arg2) + 0, (byte) (0)); + label_6: { + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local4 + 24)); + callArgs_5[0] = ((long) arg2); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + if (((int) callResult_5[0]) != 0) { + break label_6; + } + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg2 = 14377; + label_7: { + label_8: { + switch(local5) { + case 0: + { + break label_7; + } + case 1: + { + break label_8; + } + default: + { + break label_3; + } + } + } + arg2 = 11424; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local6); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg0); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local4); + callArgs_6[1] = ((long) 31593); + callArgs_6[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 61628)); + long[] callResult_6 = instance.getMachine().call(1847, callArgs_6); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 59), -1) != 0) { + break label_9; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 48)); + instance.getMachine().call(1777, callArgs_7); + } + instance.global(0).setValue(((long) (local4 + 208))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_802(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_802(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_803(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 44, (int) 0); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 44)); + callArgs_0[1] = ((long) (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local4 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(177, callArgs_0); + local4 = ((int) callResult_0[0]); + if (local4 != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 14225); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 11260); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + break label_2; + } + local4 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local4); + label_4: { + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((local5 + local4), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg2); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 16)); + callArgs_2[1] = ((long) 10968); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_2); + break label_2; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local5); + local6 = (local6 + local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local5)); + local4 = 0; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(571, callArgs_3); + if (((int) callResult_3[0]) != 0) { + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) arg2); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local3 + 32)); + callArgs_4[1] = ((long) 10994); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_4); + } + local4 = 1; + } + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_803(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_803(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_804(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[16]; + long[] lL = new long[1]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = arg2; + iL[3] = (((int) instance.global(0).getValue()) - 480); + instance.global(0).setValue(((long) iL[3])); + memory.writeLong((int) (iL[3] + 472) < 0 ? (iL[3] + 472) : (iL[3] + 472) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 464) < 0 ? (iL[3] + 464) : (iL[3] + 464) + 0, (long) 0L); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 456, (long) 0L); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + label_13: { + label_14: { + label_15: { + label_16: { + label_17: { + label_18: { + label_19: { + label_20: { + label_21: { + label_22: { + label_23: { + label_24: { + label_25: { + int _d1 = func_804__h1(iL, lL, memory, instance); + if (_d1 == 1) + break label_1; + if (_d1 == 2) + break label_2; + if (_d1 == 3) + break label_3; + if (_d1 == 4) + break label_4; + if (_d1 == 5) + break label_5; + if (_d1 == 6) + break label_6; + if (_d1 == 7) + break label_7; + if (_d1 == 8) + break label_8; + if (_d1 == 9) + break label_9; + if (_d1 == 10) + break label_10; + if (_d1 == 11) + break label_11; + if (_d1 == 12) + break label_12; + if (_d1 == 13) + break label_13; + if (_d1 == 14) + break label_14; + if (_d1 == 15) + break label_15; + if (_d1 == 16) + break label_16; + if (_d1 == 17) + break label_17; + if (_d1 == 18) + break label_18; + if (_d1 == 19) + break label_19; + if (_d1 == 20) + break label_20; + if (_d1 == 21) + break label_21; + if (_d1 == 22) + break label_22; + if (_d1 == 23) + break label_23; + if (_d1 == 24) + break label_24; + } + long[] callArgs_355 = new long[3]; + callArgs_355[2] = ((long) 0); + callArgs_355[1] = ((long) iL[4]); + callArgs_355[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_355); + break label_1; + } + long[] callArgs_356 = new long[3]; + callArgs_356[2] = ((long) 0); + callArgs_356[1] = ((long) iL[4]); + callArgs_356[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_356); + break label_1; + } + long[] callArgs_357 = new long[3]; + callArgs_357[2] = ((long) 0); + callArgs_357[1] = ((long) iL[4]); + callArgs_357[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_357); + break label_1; + } + long[] callArgs_358 = new long[3]; + callArgs_358[2] = ((long) 0); + callArgs_358[1] = ((long) iL[4]); + callArgs_358[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_358); + break label_1; + } + long[] callArgs_359 = new long[3]; + callArgs_359[2] = ((long) 0); + callArgs_359[1] = ((long) iL[4]); + callArgs_359[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_359); + break label_1; + } + long[] callArgs_360 = new long[3]; + callArgs_360[2] = ((long) 0); + callArgs_360[1] = ((long) iL[4]); + callArgs_360[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_360); + break label_1; + } + long[] callArgs_361 = new long[3]; + callArgs_361[2] = ((long) 0); + callArgs_361[1] = ((long) iL[4]); + callArgs_361[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_361); + break label_1; + } + long[] callArgs_362 = new long[3]; + callArgs_362[2] = ((long) 0); + callArgs_362[1] = ((long) iL[4]); + callArgs_362[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_362); + break label_1; + } + long[] callArgs_363 = new long[3]; + callArgs_363[2] = ((long) 0); + callArgs_363[1] = ((long) iL[4]); + callArgs_363[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_363); + break label_1; + } + long[] callArgs_364 = new long[3]; + callArgs_364[2] = ((long) 0); + callArgs_364[1] = ((long) iL[4]); + callArgs_364[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_364); + break label_1; + } + long[] callArgs_365 = new long[3]; + callArgs_365[2] = ((long) 0); + callArgs_365[1] = ((long) iL[4]); + callArgs_365[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_365); + break label_1; + } + long[] callArgs_366 = new long[3]; + callArgs_366[2] = ((long) 0); + callArgs_366[1] = ((long) iL[4]); + callArgs_366[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_366); + break label_1; + } + long[] callArgs_367 = new long[3]; + callArgs_367[2] = ((long) 0); + callArgs_367[1] = ((long) iL[4]); + callArgs_367[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_367); + break label_1; + } + long[] callArgs_368 = new long[3]; + callArgs_368[2] = ((long) 0); + callArgs_368[1] = ((long) iL[4]); + callArgs_368[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_368); + break label_1; + } + long[] callArgs_369 = new long[3]; + callArgs_369[2] = ((long) 0); + callArgs_369[1] = ((long) iL[4]); + callArgs_369[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_369); + break label_1; + } + long[] callArgs_370 = new long[3]; + callArgs_370[2] = ((long) 0); + callArgs_370[1] = ((long) iL[4]); + callArgs_370[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_370); + break label_1; + } + long[] callArgs_371 = new long[3]; + callArgs_371[2] = ((long) 0); + callArgs_371[1] = ((long) iL[4]); + callArgs_371[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_371); + break label_1; + } + long[] callArgs_372 = new long[3]; + callArgs_372[2] = ((long) 0); + callArgs_372[1] = ((long) iL[4]); + callArgs_372[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_372); + break label_1; + } + long[] callArgs_373 = new long[3]; + callArgs_373[2] = ((long) 0); + callArgs_373[1] = ((long) iL[4]); + callArgs_373[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_373); + break label_1; + } + long[] callArgs_374 = new long[3]; + callArgs_374[2] = ((long) 0); + callArgs_374[1] = ((long) iL[4]); + callArgs_374[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_374); + break label_1; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 96, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[14], 0) != 0 ? 29327 : 38861)); + iL[4] = (iL[14] >> 31); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 100, (int) ((iL[14] ^ iL[4]) - iL[4])); + long[] callArgs_375 = new long[3]; + callArgs_375[2] = ((long) (iL[3] + 96)); + callArgs_375[1] = ((long) 29455); + callArgs_375[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_375); + break label_1; + } + long[] callArgs_376 = new long[3]; + callArgs_376[2] = ((long) 0); + callArgs_376[1] = ((long) iL[4]); + callArgs_376[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_376); + break label_1; + } + long[] callArgs_377 = new long[3]; + callArgs_377[2] = ((long) 0); + callArgs_377[1] = ((long) iL[4]); + callArgs_377[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_377); + break label_1; + } + long[] callArgs_378 = new long[3]; + callArgs_378[2] = ((long) 0); + callArgs_378[1] = ((long) iL[4]); + callArgs_378[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_378); + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 476, (int) 0); + label_271: { + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 464); + iL[0] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460); + iL[12] = (iL[4] - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[12], 9) != 0) { + break label_271; + } + label_272: while (true) { + long[] callArgs_379 = new long[1]; + callArgs_379[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(1777, callArgs_379); + iL[0] = (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + 4); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 460, (int) iL[0]); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 464); + iL[12] = (iL[4] - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[12], 8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_272; + } + break; + } + } + iL[8] = 512; + label_273: { + label_274: { + label_275: { + switch(((iL[12] >>> 2) + -1)) { + case 0: + { + break label_274; + } + case 1: + { + break label_275; + } + default: + { + break label_273; + } + } + } + iL[8] = 1024; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 472, (int) iL[8]); + } + label_276: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[4], iL[0]) != 0) { + break label_276; + } + label_277: while (true) { + long[] callArgs_380 = new long[1]; + callArgs_380[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(1777, callArgs_380); + iL[0] = (iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_277; + } + break; + } + iL[0] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 464); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[4], iL[0]) != 0) { + break label_276; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 464, (int) (iL[0] + (((iL[4] - iL[0]) + 3) & -4))); + } + label_278: { + iL[0] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 456); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_278; + } + long[] callArgs_381 = new long[1]; + callArgs_381[0] = ((long) iL[0]); + instance.getMachine().call(1777, callArgs_381); + } + instance.global(0).setValue(((long) (iL[3] + 480))); + return iL[11]; + } + + public static long[] call_804(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_804(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_805(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) 0); + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 28)); + callArgs_0[1] = ((long) (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local4 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(179, callArgs_0); + local4 = ((int) callResult_0[0]); + if (local4 != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 11290); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + local4 = 1; + break label_1; + } + local5 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local5); + label_3: { + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, local4) != 0) { + break label_3; + } + local4 = 0; + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) 0); + label_4: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 24)); + callArgs_2[1] = ((long) (local6 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_2[0] = ((long) (local6 + local5)); + long[] callResult_2 = instance.getMachine().call(179, callArgs_2); + local5 = ((int) callResult_2[0]); + if (local5 != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg2); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) 11290); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_3); + local4 = 1; + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local5)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) ((((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 24) & 0xFFFFFFFFL) << 32L) | 4294967275L)); + break label_1; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local4) | -4294967296L)); + local4 = 0; + } + instance.global(0).setValue(((long) (local3 + 32))); + return local4; + } + + public static long[] call_805(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_805(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_806(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) -64L); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 15976); + callArgs_0[1] = ((long) (local3 + 24)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(805, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + local5 = memory.readInt((int) (arg0 + 100) < 0 ? (arg0 + 100) : (arg0 + 100) + 0); + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + local6 = memory.readLong((int) local3 < 0 ? local3 : local3 + 24); + local7 = (int) local6; + switch((local7 + 23)) { + case 0: + { + break label_7; + } + case 1: + { + break label_2; + } + case 2: + { + break label_6; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_2; + } + case 6: + { + break label_4; + } + case 7: + { + break label_4; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_5; + } + case 19: + { + break label_3; + } + case 20: + { + break label_3; + } + case 21: + { + break label_3; + } + case 22: + { + break label_3; + } + default: + { + break label_2; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) != 0) { + break label_2; + } + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 6) & 0xFF)) != 0) { + break label_2; + } + break label_3; + } + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 4) & 0xFF) != 0) { + break label_3; + } + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 10) & 0xFF)) != 0) { + break label_2; + } + } + local4 = 1; + label_8: { + local5 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + local7 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local7, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_8; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) 1083); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) 7656); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 16)); + callArgs_1[1] = ((long) 10873); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + break label_1; + } + local5 = ((int) memory.read((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local5) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local5) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local5) + 0) & 0xFF); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local7); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2) != 0) { + break label_9; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 28438); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_2); + local4 = 1; + break label_1; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local6); + local4 = 0; + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 0, (byte) (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5))); + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local7); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local3); + callArgs_3[1] = ((long) 2724); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_3); + } + instance.global(0).setValue(((long) (local3 + 32))); + return local4; + } + + public static long[] call_806(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_806(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_807(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) 0L); + label_1: { + label_2: { + local4 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + local5 = (local4 + 1); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local5, local6) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) 8235); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 7656); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) 10873); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_0); + local4 = 1; + break label_1; + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local4 = ((int) memory.read((int) (local7 + local4) < 0 ? (local7 + local4) : (local7 + local4) + 0) & 0xFF); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local5); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 16) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) local4); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 48)); + callArgs_1[1] = ((long) 26292); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + local4 = 1; + break label_1; + } + label_4: { + local8 = (local4 & 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_4; + } + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) + 5) & 0xFF) != 0) { + break label_4; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 18365); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_2); + local4 = 1; + break label_1; + } + label_5: { + local9 = (local4 & 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_5; + } + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) + 14) & 0xFF) != 0) { + break label_5; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) 18488); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_3); + local4 = 1; + break label_1; + } + local10 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100); + label_6: { + local11 = (local4 & 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_6; + } + if (((int) memory.read((int) local10 < 0 ? local10 : local10 + 18) & 0xFF) != 0) { + break label_6; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) 18296); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_4); + local4 = 1; + break label_1; + } + local12 = (local4 & 1); + label_7: { + label_8: { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local10 < 0 ? local10 : local10 + 14) & 0xFF)) != 0) { + break label_9; + } + label_10: { + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local3 + 72)); + callArgs_5[1] = ((long) (local7 + local6)); + callArgs_5[0] = ((long) (local7 + local5)); + long[] callResult_5 = instance.getMachine().call(178, callArgs_5); + local4 = ((int) callResult_5[0]); + if (local4 != 0) { + break label_10; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 6640); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) (local3 + 32)); + callArgs_6[1] = ((long) 11200); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_6); + local4 = 1; + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local4)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_8; + } + local4 = 1; + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 6618); + callArgs_7[1] = ((long) (local3 + 64)); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(817, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_7[0])) != 0) { + break label_8; + } + break label_1; + } + label_11: { + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (local3 + 60)); + callArgs_8[1] = ((long) (local7 + local6)); + callArgs_8[0] = ((long) (local7 + local5)); + long[] callResult_8 = instance.getMachine().call(177, callArgs_8); + local4 = ((int) callResult_8[0]); + if (local4 != 0) { + break label_11; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) 6640); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local3 + 16)); + callArgs_9[1] = ((long) 11260); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_9); + break label_7; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local4)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 72, (long) ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 60) & 0xFFFFFFFFL)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_8; + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) 6618); + callArgs_10[1] = ((long) (local3 + 56)); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(812, callArgs_10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_10[0])) != 0) { + break label_7; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 64, (long) ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 56) & 0xFFFFFFFFL)); + } + label_12: { + label_13: { + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_14; + } + local4 = 1; + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) 15143); + callArgs_11[1] = ((long) (local3 + 60)); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(812, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + break label_1; + } + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 17) != 0) { + break label_13; + } + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) 0); + callArgs_12[1] = ((long) 15133); + callArgs_12[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_12); + break label_1; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 65536); + break label_12; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (1 << local5)); + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 18, (byte) ((local9 >>> 2))); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 17, (byte) ((local8 >>> 1))); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 16, (byte) (local12)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 72)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 64)); + local4 = 0; + break label_1; + } + local4 = 1; + } + instance.global(0).setValue(((long) (local3 + 80))); + return local4; + } + + public static long[] call_807(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_807(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_808(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 60, (int) 0); + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 60)); + callArgs_0[1] = ((long) (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local4 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(179, callArgs_0); + local4 = ((int) callResult_0[0]); + if (local4 != 0) { + break label_4; + } + local4 = 11290; + break label_3; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local4)); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 60); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local5) | -4294967296L)); + local4 = 16308; + arg1 = (local5 + 23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 7) != 0) { + break label_3; + } + if (((1 << arg1) & 197) != 0) { + break label_2; + } + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 15888); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + local4 = 1; + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 56, (int) 0); + label_5: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local5 = (local4 + 1); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local5, local6) != 0) { + break label_5; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) 8309); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) 7656); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 16)); + callArgs_2[1] = ((long) 10873); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_2); + local4 = 1; + break label_1; + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + arg1 = ((int) memory.read((int) (local7 + local4) < 0 ? (local7 + local4) : (local7 + local4) + 0) & 0xFF); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local5); + local4 = 1; + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg1 & 2)) != 0) { + break label_6; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) 18819); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_3); + break label_1; + } + label_7: { + local8 = (arg1 & 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_7; + } + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) + 14) & 0xFF) != 0) { + break label_7; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) 18488); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_4); + break label_1; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 8) != 0) { + break label_8; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 48, (int) arg1); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local3 + 48)); + callArgs_5[1] = ((long) 26325); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_5); + break label_1; + } + label_9: { + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) (local3 + 60)); + callArgs_6[1] = ((long) (local7 + local6)); + callArgs_6[0] = ((long) (local7 + local5)); + long[] callResult_6 = instance.getMachine().call(177, callArgs_6); + local5 = ((int) callResult_6[0]); + if (local5 != 0) { + break label_9; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 6443); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local3 + 32)); + callArgs_7[1] = ((long) 11260); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_7); + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local5)); + local9 = 0L; + label_10: { + arg1 = (arg1 & 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_10; + } + local4 = 1; + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 6422); + callArgs_8[1] = ((long) (local3 + 56)); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(812, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_8[0])) != 0) { + break label_1; + } + local9 = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 56) & 0xFFFFFFFFL); + } + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 18, (byte) ((local8 >>> 2))); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 16, (byte) (arg1)); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 8, (long) local9); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 60) & 0xFFFFFFFFL)); + local4 = 0; + } + instance.global(0).setValue(((long) (local3 + 64))); + return local4; + } + + public static long[] call_808(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_808(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_809(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 12), arg1) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + local2 = ((arg1 * 12) + -12); + local2 = ((local2 - com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local2, 12)) + 12); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + local3 = (((int) callResult_0[0]) + local2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + return; + } + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 12); + local6 = (local5 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 357913942) != 0) { + break label_4; + } + local7 = 0; + label_5: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local4), 12); + local8 = (local2 << 1); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 357913942) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local6 * 12)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + } + local2 = (local7 + (local5 * 12)); + arg1 = ((arg1 * 12) + -12); + arg1 = ((arg1 - com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg1, 12)) + 12); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + arg1 = (((int) callResult_2[0]) + arg1); + local7 = (local7 + (local6 * 12)); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_6; + } + label_7: while (true) { + local2 = (local2 + -12); + local3 = (local3 + -12); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (int) memory.readInt((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_8; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_809(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_809(arg0, arg1, memory, instance); + return null; + } + + public static int func_810(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + long local5 = 0L; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 16336); + callArgs_0[1] = ((long) (local2 + 24)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(805, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + local4 = memory.readInt((int) (arg0 + 100) < 0 ? (arg0 + 100) : (arg0 + 100) + 0); + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + local5 = memory.readLong((int) local2 < 0 ? local2 : local2 + 24); + local6 = (int) local5; + switch((local6 + 23)) { + case 0: + { + break label_7; + } + case 1: + { + break label_2; + } + case 2: + { + break label_6; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_2; + } + case 6: + { + break label_4; + } + case 7: + { + break label_4; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_5; + } + case 19: + { + break label_3; + } + case 20: + { + break label_3; + } + case 21: + { + break label_3; + } + case 22: + { + break label_3; + } + default: + { + break label_2; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_2; + } + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 6) & 0xFF)) != 0) { + break label_2; + } + break label_3; + } + if (((int) memory.read((int) local4 < 0 ? local4 : local4 + 4) & 0xFF) != 0) { + break label_3; + } + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 10) & 0xFF)) != 0) { + break label_2; + } + } + local3 = 1; + label_8: { + local6 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + local4 = (local6 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local4, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_8; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) 1101); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 7656); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) 10873); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + break label_1; + } + local6 = ((int) memory.read((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local6) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local6) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local6) + 0) & 0xFF); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local4); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 2) != 0) { + break label_9; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 28471); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_2); + local3 = 1; + break label_1; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local5); + local3 = 0; + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 8, (byte) (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local6))); + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? 29327 : 38861)); + arg1 = (local6 >> 31); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) ((local6 ^ arg1) - arg1)); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 29578); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_3); + } + instance.global(0).setValue(((long) (local2 + 32))); + return local3; + } + + public static long[] call_810(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_810(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_811(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + label_2: { + local5 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((local5 + 1), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 7656); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) 10873); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_0); + break label_1; + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (((int) memory.read((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local5) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local5) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local5) + 0) & 0xFF))); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 1)); + local4 = 0; + } + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_811(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_811(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_812(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local4 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(177, callArgs_0); + arg1 = ((int) callResult_0[0]); + if (arg1 != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 11260); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + arg0 = 1; + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + arg1)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg0; + } + + public static long[] call_812(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_812(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_813(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 28)); + callArgs_0[1] = ((long) (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local4 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(177, callArgs_0); + local4 = ((int) callResult_0[0]); + if (local4 != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 11260); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + break label_2; + } + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 28); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local5); + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg1); + local4 = 0; + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) - arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local5, arg1) != 0) { + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg2); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 16)); + callArgs_2[1] = ((long) 12552); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_2); + } + local4 = 1; + } + instance.global(0).setValue(((long) (local3 + 32))); + return local4; + } + + public static long[] call_813(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_813(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_814(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 12)); + callArgs_0[1] = ((long) (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local4 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(177, callArgs_0); + local4 = ((int) callResult_0[0]); + if (local4 != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 11260); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + arg0 = 1; + break label_1; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 12)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local4)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg0; + } + + public static long[] call_814(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_814(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_815(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local4 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(179, callArgs_0); + arg1 = ((int) callResult_0[0]); + if (arg1 != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 11290); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + arg0 = 1; + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + arg1)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg0; + } + + public static long[] call_815(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_815(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_816(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 - local3)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(248, callArgs_0); + return; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local3, arg1) != 0) { + break label_2; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + (arg1 << 3))); + } + return; + } + + public static long[] call_816(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_816(arg0, arg1, memory, instance); + return null; + } + + public static int func_817(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local4 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(178, callArgs_0); + arg1 = ((int) callResult_0[0]); + if (arg1 != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 11200); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + arg0 = 1; + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + arg1)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg0; + } + + public static long[] call_817(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_817(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_818(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) 0); + label_1: { + label_2: { + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 12)); + callArgs_0[1] = ((long) (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local4 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(179, callArgs_0); + local4 = ((int) callResult_0[0]); + if (local4 != 0) { + break label_3; + } + arg1 = 11290; + break label_2; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local4)); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local4) | -4294967296L)); + arg1 = 16308; + local5 = (local4 + 23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 8) != 0) { + break label_2; + } + local4 = 0; + if (((197 >>> (local5 & 255)) & 1) != 0) { + break label_1; + } + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + local4 = 1; + } + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_818(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_818(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_819(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 72, (int) arg1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 32); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + arg1 = ((int) callResult_0[0]); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 17, (byte) (0)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 17473)); + memory.writeLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 17481)); + memory.writeByte((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 17489) & 0xFF))); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) arg1); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 60, (long) -9223371899415822319L); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 27556); + callArgs_1[0] = ((long) (local2 + 56)); + long[] callResult_1 = instance.getMachine().call(1662, callArgs_1); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 72)); + callArgs_2[0] = ((long) (local2 + 40)); + instance.getMachine().call(196, callArgs_2); + label_1: { + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 40); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg1) != 0) { + break label_1; + } + label_2: while (true) { + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) 2626); + callArgs_3[0] = ((long) (local2 + 24)); + instance.getMachine().call(39, callArgs_3); + local4 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 35) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 28) : local4)); + callArgs_4[1] = ((long) (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 24) : (local2 + 24))); + callArgs_4[0] = ((long) (local2 + 56)); + long[] callResult_4 = instance.getMachine().call(1652, callArgs_4); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 35), -1) != 0) { + break label_3; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 24)); + instance.getMachine().call(1777, callArgs_5); + } + arg1 = (arg1 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 56) : (local2 + 56))); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local2); + callArgs_6[1] = ((long) 11317); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_6); + label_4: { + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_4; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 44, (int) arg1); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_7); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), -1) != 0) { + break label_5; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 56)); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local2 + 80))); + return 1; + } + + public static long[] call_819(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_819(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_820(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20); + _snap_0 = local2; + local2 = (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, _snap_0) != 0 ? 0 : (((_snap_0 - local3) << 8) + -1))) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(832, callArgs_0); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20); + local2 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local4 + 1)); + memory.writeI32((int) (memory.readInt((int) (local3 + ((local2 >>> 8) & 16777212)) < 0 ? (local3 + ((local2 >>> 8) & 16777212)) : (local3 + ((local2 >>> 8) & 16777212)) + 0) + ((local2 & 1023) << 2)) < 0 ? (memory.readInt((int) (local3 + ((local2 >>> 8) & 16777212)) < 0 ? (local3 + ((local2 >>> 8) & 16777212)) : (local3 + ((local2 >>> 8) & 16777212)) + 0) + ((local2 & 1023) << 2)) : (memory.readInt((int) (local3 + ((local2 >>> 8) & 16777212)) < 0 ? (local3 + ((local2 >>> 8) & 16777212)) : (local3 + ((local2 >>> 8) & 16777212)) + 0) + ((local2 & 1023) << 2)) + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + + public static long[] call_820(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_820(arg0, arg1, memory, instance); + return null; + } + + public static int func_821(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = 1; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + switch((arg1 + 64)) { + case 0: + { + break label_1; + } + case 1: + { + break label_2; + } + case 2: + { + break label_2; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_2; + } + case 6: + { + break label_2; + } + case 7: + { + break label_2; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_2; + } + case 19: + { + break label_2; + } + case 20: + { + break label_2; + } + case 21: + { + break label_2; + } + case 22: + { + break label_2; + } + case 23: + { + break label_2; + } + case 24: + { + break label_2; + } + case 25: + { + break label_2; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_2; + } + case 29: + { + break label_2; + } + case 30: + { + break label_2; + } + case 31: + { + break label_2; + } + case 32: + { + break label_2; + } + case 33: + { + break label_2; + } + case 34: + { + break label_2; + } + case 35: + { + break label_2; + } + case 36: + { + break label_2; + } + case 37: + { + break label_2; + } + case 38: + { + break label_2; + } + case 39: + { + break label_2; + } + case 40: + { + break label_2; + } + case 41: + { + break label_5; + } + case 42: + { + break label_2; + } + case 43: + { + break label_4; + } + case 44: + { + break label_2; + } + case 45: + { + break label_2; + } + case 46: + { + break label_2; + } + case 47: + { + break label_6; + } + case 48: + { + break label_6; + } + case 49: + { + break label_2; + } + case 50: + { + break label_2; + } + case 51: + { + break label_2; + } + case 52: + { + break label_2; + } + case 53: + { + break label_2; + } + case 54: + { + break label_2; + } + case 55: + { + break label_2; + } + case 56: + { + break label_2; + } + case 57: + { + break label_2; + } + case 58: + { + break label_2; + } + case 59: + { + break label_3; + } + case 60: + { + break label_1; + } + case 61: + { + break label_1; + } + case 62: + { + break label_1; + } + case 63: + { + break label_1; + } + default: + { + break label_2; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 10) & 0xFF)) != 0) { + break label_2; + } + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_2; + } + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 6) & 0xFF)) != 0) { + break label_2; + } + break label_1; + } + if (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 4) & 0xFF) != 0) { + break label_1; + } + } + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 7) & 0xFF)) & com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg1, -1)); + } + return local2; + } + + public static long[] call_821(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_821(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_822(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2) >> 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 - local3)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(833, callArgs_0); + return; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local3, arg1) != 0) { + break label_2; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + (arg1 << 2))); + } + return; + } + + public static long[] call_822(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_822(arg0, arg1, memory, instance); + return null; + } + + public static int func_823(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) (local3 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local3 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(180, callArgs_0); + arg1 = ((int) callResult_0[0]); + if (arg1 != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 15328); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) 11230); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + arg0 = 1; + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + arg1)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local2 + 16))); + return arg0; + } + + public static long[] call_823(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_823(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_824(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((local3 + 4), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) 15376); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 7507); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 10873); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_0); + arg0 = 1; + break label_1; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local3) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local3) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local3) + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 4)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local2 + 16))); + return arg0; + } + + public static long[] call_824(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_824(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_825(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((local3 + 8), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) 15344); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 17212); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 10873); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_0); + arg0 = 1; + break label_1; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local3) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local3) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local3) + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 8)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local2 + 16))); + return arg0; + } + + public static long[] call_825(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_825(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_826(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((local4 + 16), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 27638); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) 10873); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_0); + arg0 = 1; + break label_1; + } + arg2 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local4); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 16)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg0; + } + + public static long[] call_826(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_826(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_827(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local8 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local8)); + label_1: { + label_2: { + label_3: { + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local8 + 92)); + callArgs_0[1] = ((long) (local9 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local9 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(177, callArgs_0); + local9 = ((int) callResult_0[0]); + if (local9 != 0) { + break label_3; + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) arg4); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local8); + callArgs_1[1] = ((long) 11260); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + break label_2; + } + local10 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local10); + local11 = memory.readInt((int) local8 < 0 ? local8 : local8 + 92); + local9 = (local11 & -65); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local9)); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, 32) != 0) { + break label_4; + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 20, (int) local9); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 16, (int) arg4); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local8 + 16)); + callArgs_2[1] = ((long) 5501); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_2); + break label_2; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 0); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local11 & 64)) != 0) { + break label_6; + } + label_7: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) + 15) & 0xFF) != 0) { + break label_7; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) 17923); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_3); + break label_2; + } + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local8 + 92)); + callArgs_4[1] = ((long) (local9 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_4[0] = ((long) (local9 + local10)); + long[] callResult_4 = instance.getMachine().call(177, callArgs_4); + local9 = ((int) callResult_4[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_5; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 92)); + local10 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local10); + } + label_8: { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100) + 14) & 0xFF)) != 0) { + break label_9; + } + label_10: { + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) arg3); + callArgs_5[1] = ((long) (local9 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_5[0] = ((long) (local9 + local10)); + long[] callResult_5 = instance.getMachine().call(178, callArgs_5); + local9 = ((int) callResult_5[0]); + if (local9 != 0) { + break label_10; + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 64, (int) arg6); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) (local8 + 64)); + callArgs_6[1] = ((long) 11200); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_6); + break label_2; + } + arg4 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local9); + break label_8; + } + label_11: { + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local8 + 92)); + callArgs_7[1] = ((long) (local9 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_7[0] = ((long) (local9 + local10)); + long[] callResult_7 = instance.getMachine().call(177, callArgs_7); + local9 = ((int) callResult_7[0]); + if (local9 != 0) { + break label_11; + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 32, (int) arg6); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (local8 + 32)); + callArgs_8[1] = ((long) 11260); + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_8); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 92) & 0xFFFFFFFFL)); + break label_2; + } + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 92) & 0xFFFFFFFFL)); + arg4 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local9); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg4); + local9 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg7) != 0) { + break label_1; + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((arg4 + 1), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_12; + } + memory.writeByte((int) arg7 < 0 ? arg7 : arg7 + 0, (byte) (((int) memory.read((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + arg4) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + arg4) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + arg4) + 0) & 0xFF))); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 1)); + break label_1; + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 52, (int) 2423); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 48, (int) 7656); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local8 + 48)); + callArgs_9[1] = ((long) 10873); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_9); + break label_2; + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 80, (int) arg5); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) (local8 + 80)); + callArgs_10[1] = ((long) 11260); + callArgs_10[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_10); + } + local9 = 1; + } + instance.global(0).setValue(((long) (local8 + 96))); + return local9; + } + + public static long[] call_827(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int arg7 = ((int) args[7]); + int result = Wat2WasmMachine.func_827(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_828(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 12)); + callArgs_0[1] = ((long) (local4 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0))); + callArgs_0[0] = ((long) (local4 + memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0))); + long[] callResult_0 = instance.getMachine().call(177, callArgs_0); + local4 = ((int) callResult_0[0]); + if (local4 != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 11260); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_1); + arg0 = 1; + break label_1; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 12)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + local4)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg0; + } + + public static long[] call_828(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_828(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_829(int arg0, long arg1, int arg2, long arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local5 = (int) arg3; + local6 = (int) arg1; + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_2; + } + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + local9 = ((int) memory.read((int) arg4 < 0 ? arg4 : arg4 + 0) & 0xFF); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_3; + } + arg4 = 25903; + int ciTableIdx_0 = (int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 252)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) local9); + callArgs_0[3] = ((long) local5); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local7); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + return 0; + } + arg4 = 25860; + int ciTableIdx_1 = (int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 248)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local9); + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) local6); + callArgs_1[0] = ((long) local7); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + if (((int) callResult_1[0]) != 0) { + break label_1; + } + return 0; + } + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_4; + } + arg4 = 25860; + int ciTableIdx_2 = (int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 248)); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local5); + callArgs_2[2] = ((long) arg2); + callArgs_2[1] = ((long) local6); + callArgs_2[0] = ((long) local7); + long[] callResult_2 = ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + if (((int) callResult_2[0]) != 0) { + break label_1; + } + return 0; + } + arg4 = 25823; + int ciTableIdx_3 = (int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 244)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local5); + callArgs_3[1] = ((long) local6); + callArgs_3[0] = ((long) local7); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + if (((int) callResult_3[0]) != 0) { + break label_1; + } + return 0; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) arg4); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(802, callArgs_4); + return 1; + } + + public static long[] call_829(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int arg2 = ((int) args[2]); + long arg3 = args[3]; + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_829(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_830(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, arg1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 - local3)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(834, callArgs_0); + return; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local3, arg1) != 0) { + break label_2; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + (arg1 * 12))); + } + return; + } + + public static long[] call_830(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_830(arg0, arg1, memory, instance); + return null; + } + + public static void func_831(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local1 + -1)); + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((((com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0 ? 0 : (((local2 - local3) << 8) + -1)) - (local1 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16))) + 1), 2048) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) (local2 + -4) < 0 ? (local2 + -4) : (local2 + -4) + 0)); + instance.getMachine().call(1777, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + -4)); + } + return; + } + + public static long[] call_831(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_831(arg0, memory, instance); + return null; + } + + public static void func_832(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local1 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 1024) != 0) { + break label_3; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (local2 + -1024)); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + local2 = (local2 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + label_4: { + label_5: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12), local4) != 0) { + break label_5; + } + local5 = local4; + break label_4; + } + label_6: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local2, local6) != 0) { + break label_6; + } + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local2 - local6) >> 2) + 1), -2) << 2); + local4 = (local4 - local2); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local4); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) (local2 + local6)); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + local5 = (((int) callResult_0[0]) + local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local6)); + break label_4; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0 ? 1 : ((local4 - local6) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 1073741824) != 0) { + break label_1; + } + local7 = (local5 << 2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local7); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local8 = ((int) callResult_1[0]); + local9 = (local8 + local7); + local7 = (local8 + (local5 & -4)); + local5 = local7; + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local4) != 0) { + break label_7; + } + local4 = (local4 - local2); + local10 = (local4 & -4); + label_8: { + label_9: { + local11 = (local4 + -4); + local5 = (((local11 >>> 2) + 1) & 7); + if (local5 != 0) { + break label_9; + } + local4 = local7; + break label_8; + } + local4 = local7; + label_10: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + local2 = (local2 + 4); + local4 = (local4 + 4); + local5 = (local5 + -1); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + local5 = (local7 + local10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local11, 28) != 0) { + break label_7; + } + label_11: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (int) memory.readInt((int) (local2 + 4) < 0 ? (local2 + 4) : (local2 + 4) + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + memory.writeI32((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (int) memory.readInt((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0)); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0)); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) memory.readInt((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0)); + memory.writeI32((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (int) memory.readInt((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local2 + 28) < 0 ? (local2 + 28) : (local2 + 28) + 0)); + local2 = (local2 + 32); + local4 = (local4 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_4; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 4)); + break label_2; + } + label_12: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local9 = (local2 - local4); + local6 = (local9 >> 2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local7 = (local5 - local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, (local7 >> 2)) != 0) { + break label_12; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local5) != 0) { + break label_13; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 4096); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) ((int) callResult_3[0])); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local1 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(835, callArgs_4); + break label_2; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 4096); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) ((int) callResult_5[0])); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local1 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(836, callArgs_6); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + local2 = (local2 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + label_14: { + label_15: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12), local4) != 0) { + break label_15; + } + local5 = local4; + break label_14; + } + label_16: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local2, local6) != 0) { + break label_16; + } + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local2 - local6) >> 2) + 1), -2) << 2); + local4 = (local4 - local2); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local4); + callArgs_7[1] = ((long) local2); + callArgs_7[0] = ((long) (local2 + local6)); + long[] callResult_7 = instance.getMachine().call(1891, callArgs_7); + local5 = (((int) callResult_7[0]) + local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local6)); + break label_14; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0 ? 1 : ((local4 - local6) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 1073741824) != 0) { + break label_1; + } + local7 = (local5 << 2); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local7); + long[] callResult_8 = instance.getMachine().call(1776, callArgs_8); + local8 = ((int) callResult_8[0]); + local9 = (local8 + local7); + local7 = (local8 + (local5 & -4)); + local5 = local7; + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local4) != 0) { + break label_17; + } + local4 = (local4 - local2); + local10 = (local4 & -4); + label_18: { + label_19: { + local11 = (local4 + -4); + local5 = (((local11 >>> 2) + 1) & 7); + if (local5 != 0) { + break label_19; + } + local4 = local7; + break label_18; + } + local4 = local7; + label_20: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + local2 = (local2 + 4); + local4 = (local4 + 4); + local5 = (local5 + -1); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + } + local5 = (local7 + local10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local11, 28) != 0) { + break label_17; + } + label_21: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (int) memory.readInt((int) (local2 + 4) < 0 ? (local2 + 4) : (local2 + 4) + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + memory.writeI32((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (int) memory.readInt((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0)); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0)); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) memory.readInt((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0)); + memory.writeI32((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (int) memory.readInt((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local2 + 28) < 0 ? (local2 + 28) : (local2 + 28) + 0)); + local2 = (local2 + 32); + local4 = (local4 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_21; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_14; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_9); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 4)); + break label_2; + } + memory.writeI32((int) (local1 + 24) < 0 ? (local1 + 24) : (local1 + 24) + 0, (int) (arg0 + 12)); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0 ? 1 : (local7 >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 1073741824) != 0) { + break label_1; + } + local5 = (local7 << 2); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local5); + long[] callResult_10 = instance.getMachine().call(1776, callArgs_10); + local3 = ((int) callResult_10[0]); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) local3); + local8 = (local3 + local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 20, (int) local8); + local5 = (local3 + (local6 << 2)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local5); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) 4096); + long[] callResult_11 = instance.getMachine().call(1776, callArgs_11); + local10 = ((int) callResult_11[0]); + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local6) != 0) { + break label_22; + } + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local9, 1) != 0) { + break label_23; + } + local5 = (local5 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 + 1), -2) << 2)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local5); + break label_22; + } + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0 ? 1 : (local9 >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 1073741824) != 0) { + break label_1; + } + local4 = (local2 << 2); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local4); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + local6 = ((int) callResult_12[0]); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) local6); + local8 = (local6 + local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 20, (int) local8); + local5 = (local6 + (local2 & -4)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local5); + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_13); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = local6; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local10); + local7 = (local5 + 4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 16, (int) local7); + local6 = local4; + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_24; + } + label_25: while (true) { + local2 = (local2 + -4); + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) local2); + callArgs_14[0] = ((long) (local1 + 8)); + instance.getMachine().call(837, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4), local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_25; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local8 = memory.readInt((int) local1 < 0 ? local1 : local1 + 20); + local7 = memory.readInt((int) local1 < 0 ? local1 : local1 + 16); + local5 = memory.readInt((int) local1 < 0 ? local1 : local1 + 12); + local3 = memory.readInt((int) local1 < 0 ? local1 : local1 + 8); + local6 = local2; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local8); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) local2); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 20, (int) local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 16, (int) local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local6); + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_26; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 16, (int) (local4 + (((local6 - local4) + 3) & -4))); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_15); + } + instance.global(0).setValue(((long) (local1 + 32))); + return; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_832(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_832(arg0, memory, instance); + return null; + } + + public static void func_833(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(((local2 - local3) >> 2), arg1) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + local2 = (arg1 << 2); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + local3 = (((int) callResult_0[0]) + local2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + return; + } + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = ((local3 - local4) >> 2); + local6 = (local5 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 1073741824) != 0) { + break label_4; + } + local7 = 0; + label_5: { + local2 = (local2 - local4); + local8 = (local2 >>> 1); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6) : 1073741823); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 1073741824) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local6 << 2)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + } + local2 = (local7 + (local5 << 2)); + arg1 = (arg1 << 2); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + arg1 = (((int) callResult_2[0]) + arg1); + local7 = (local7 + (local6 << 2)); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_6; + } + label_7: while (true) { + local2 = (local2 + -4); + local3 = (local3 + -4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_8; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_833(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_833(arg0, arg1, memory, instance); + return null; + } + + public static void func_834(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 12), arg1) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + local2 = ((arg1 * 12) + -12); + local2 = ((local2 - com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local2, 12)) + 12); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + local3 = (((int) callResult_0[0]) + local2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + return; + } + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 12); + local6 = (local5 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 357913942) != 0) { + break label_4; + } + local7 = 0; + label_5: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local4), 12); + local8 = (local2 << 1); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 357913942) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local6 * 12)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + } + local2 = (local7 + (local5 * 12)); + arg1 = ((arg1 * 12) + -12); + arg1 = ((arg1 - com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg1, 12)) + 12); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + arg1 = (((int) callResult_2[0]) + arg1); + local7 = (local7 + (local6 * 12)); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_6; + } + label_7: while (true) { + local2 = (local2 + -12); + local3 = (local3 + -12); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (int) memory.readInt((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_8; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_834(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_834(arg0, arg1, memory, instance); + return null; + } + + public static void func_835(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12), local2) != 0) { + break label_3; + } + local3 = local2; + break label_2; + } + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local4, local5) != 0) { + break label_4; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local4 - local5) >> 2) + 1), -2) << 2); + local2 = (local2 - local4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (local4 + local5)); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + local3 = (((int) callResult_0[0]) + local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local5)); + break label_2; + } + local3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local2) != 0 ? 1 : ((local2 - local5) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 1073741824) != 0) { + break label_1; + } + local6 = (local3 << 2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + local8 = (local7 + local6); + local6 = (local7 + (local3 & -4)); + local3 = local6; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_5; + } + local2 = (local2 - local4); + local9 = (local2 & -4); + label_6: { + label_7: { + local10 = (local2 + -4); + local3 = (((local10 >>> 2) + 1) & 7); + if (local3 != 0) { + break label_7; + } + local2 = local6; + break label_6; + } + local2 = local6; + label_8: while (true) { + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + local4 = (local4 + 4); + local2 = (local2 + 4); + local3 = (local3 + -1); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + local3 = (local6 + local9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, 28) != 0) { + break label_5; + } + label_9: while (true) { + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local2 + 4) < 0 ? (local2 + 4) : (local2 + 4) + 0, (int) memory.readInt((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0)); + memory.writeI32((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (int) memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeI32((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0, (int) memory.readInt((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0)); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) memory.readInt((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + memory.writeI32((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0, (int) memory.readInt((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0)); + memory.writeI32((int) (local2 + 28) < 0 ? (local2 + 28) : (local2 + 28) + 0, (int) memory.readInt((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0)); + local4 = (local4 + 32); + local2 = (local2 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 4)); + return; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_835(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_835(arg0, arg1, memory, instance); + return null; + } + + public static void func_836(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0), local2) != 0) { + break label_3; + } + local3 = local2; + break label_2; + } + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_4; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local5 - local4) >> 2) + 1), 2) << 2); + _snap_0 = local4; + local4 = (local4 - local2); + local3 = ((_snap_0 + local5) - local4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local4); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) ((int) callResult_0[0])); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + local5)); + break label_2; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local5) != 0 ? 1 : ((local5 - local2) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 1073741824) != 0) { + break label_1; + } + local6 = (local5 << 2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + local8 = (local7 + local6); + local3 = (local7 + ((local5 + 3) & -4)); + local6 = local3; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local4) != 0) { + break label_5; + } + local6 = (local4 - local2); + local9 = (local6 & -4); + local4 = local3; + local5 = local2; + label_6: { + local10 = (local6 + -4); + local6 = (((local10 >>> 2) + 1) & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_6; + } + local4 = local3; + local5 = local2; + label_7: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + local5 = (local5 + 4); + local4 = (local4 + 4); + local6 = (local6 + -1); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + local6 = (local3 + local9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, 28) != 0) { + break label_5; + } + label_8: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (int) memory.readInt((int) (local5 + 4) < 0 ? (local5 + 4) : (local5 + 4) + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + memory.writeI32((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (int) memory.readInt((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0)); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0)); + memory.writeI32((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (int) memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0)); + local5 = (local5 + 32); + local4 = (local4 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeI32((int) (local3 + -4) < 0 ? (local3 + -4) : (local3 + -4) + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + -4)); + return; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_836(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_836(arg0, arg1, memory, instance); + return null; + } + + public static void func_837(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0), local2) != 0) { + break label_3; + } + local3 = local2; + break label_2; + } + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_4; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local5 - local4) >> 2) + 1), 2) << 2); + _snap_0 = local4; + local4 = (local4 - local2); + local3 = ((_snap_0 + local5) - local4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local4); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) ((int) callResult_0[0])); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + local5)); + break label_2; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local5) != 0 ? 1 : ((local5 - local2) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 1073741824) != 0) { + break label_1; + } + local6 = (local5 << 2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + local8 = (local7 + local6); + local3 = (local7 + ((local5 + 3) & -4)); + local6 = local3; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local4) != 0) { + break label_5; + } + local6 = (local4 - local2); + local9 = (local6 & -4); + local4 = local3; + local5 = local2; + label_6: { + local10 = (local6 + -4); + local6 = (((local10 >>> 2) + 1) & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_6; + } + local4 = local3; + local5 = local2; + label_7: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + local5 = (local5 + 4); + local4 = (local4 + 4); + local6 = (local6 + -1); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + local6 = (local3 + local9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, 28) != 0) { + break label_5; + } + label_8: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (int) memory.readInt((int) (local5 + 4) < 0 ? (local5 + 4) : (local5 + 4) + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + memory.writeI32((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (int) memory.readInt((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0)); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0)); + memory.writeI32((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (int) memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0)); + local5 = (local5 + 32); + local4 = (local4 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeI32((int) (local3 + -4) < 0 ? (local3 + -4) : (local3 + -4) + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + -4)); + return; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_837(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_837(arg0, arg1, memory, instance); + return null; + } + + public static int func_838(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + local6 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local6)); + memory.writeLong((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0, (long) 0L); + memory.writeLong((int) (local6 + 52) < 0 ? (local6 + 52) : (local6 + 52) + 0, (long) 0L); + memory.writeLong((int) (local6 + 60) < 0 ? (local6 + 60) : (local6 + 60) + 0, (long) 0L); + memory.writeLong((int) (local6 + 68) < 0 ? (local6 + 68) : (local6 + 68) + 0, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 24, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) arg5); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) arg4); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) 45956); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 44, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 40, (int) arg0); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) (local6 + 8)); + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(801, callArgs_0); + arg5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local6 + 8)); + long[] callResult_1 = instance.getMachine().call(839, callArgs_1); + instance.global(0).setValue(((long) (local6 + 80))); + return arg5; + } + + public static long[] call_838(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int result = Wat2WasmMachine.func_838(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_839(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 45956); + label_1: { + label_2: { + local1 = memory.readInt((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0); + local2 = memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, local1) != 0) { + break label_2; + } + local1 = local2; + break label_1; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 52); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local3, 146); + local5 = (local2 + (local4 << 2)); + local4 = (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + ((local3 - (local4 * 146)) * 28)); + local3 = (memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0) + local3); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local3, 146); + local3 = (memory.readInt((int) (local2 + (local6 << 2)) < 0 ? (local2 + (local6 << 2)) : (local2 + (local6 << 2)) + 0) + ((local3 - (local6 * 146)) * 28)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_1; + } + label_3: while (true) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 4)); + long[] callResult_0 = instance.getMachine().call(840, callArgs_0); + label_4: { + local4 = (local4 + 28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(4088, (local4 - memory.readInt((int) local5 < 0 ? local5 : local5 + 0))) != 0) { + break label_4; + } + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local5 = (local5 + 4); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local1 = memory.readInt((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0); + local2 = memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0); + } + memory.writeI32((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0, (int) 0); + label_5: { + local5 = (local1 - local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 9) != 0) { + break label_5; + } + local4 = (arg0 + 40); + local3 = (arg0 + 44); + label_6: while (true) { + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_1); + local2 = (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local2); + local1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local5 = (local1 - local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + local4 = 73; + label_7: { + label_8: { + label_9: { + switch(((local5 >>> 2) + -1)) { + case 0: + { + break label_8; + } + case 1: + { + break label_9; + } + default: + { + break label_7; + } + } + } + local4 = 146; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 52, (int) local4); + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local2) != 0) { + break label_10; + } + label_11: while (true) { + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_2); + local2 = (local2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + local4 = (arg0 + 44); + local2 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local1 = memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local2) != 0) { + break label_10; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (local2 + (((local1 - local2) + 3) & -4))); + } + label_12: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_12; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + } + label_13: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_13; + } + memory.writeI32((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0, (int) local2); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_4); + } + return arg0; + } + + public static long[] call_839(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_839(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_840(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + label_1: { + label_2: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, local1) != 0) { + break label_2; + } + local3 = (arg0 + 20); + local1 = local2; + break label_1; + } + local3 = (arg0 + 20); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + local5 = (local2 + ((local4 >>> 8) & 16777212)); + local6 = (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + ((local4 & 1023) << 2)); + local4 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) + local4); + local4 = (memory.readInt((int) (local2 + ((local4 >>> 8) & 16777212)) < 0 ? (local2 + ((local4 >>> 8) & 16777212)) : (local2 + ((local4 >>> 8) & 16777212)) + 0) + ((local4 & 1023) << 2)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_1; + } + label_3: while (true) { + local2 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 0); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_4; + } + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local2); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + label_5: { + local6 = (local6 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(4096, (local6 - memory.readInt((int) local5 < 0 ? local5 : local5 + 0))) != 0) { + break label_5; + } + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local5 = (local5 + 4); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + label_6: { + local6 = (local1 - local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 9) != 0) { + break label_6; + } + label_7: while (true) { + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_1); + local2 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = (local1 - local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + local5 = 512; + label_8: { + label_9: { + label_10: { + switch(((local6 >>> 2) + -1)) { + case 0: + { + break label_9; + } + case 1: + { + break label_10; + } + default: + { + break label_8; + } + } + } + local5 = 1024; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local5); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local2) != 0) { + break label_11; + } + label_12: while (true) { + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_2); + local2 = (local2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local2) != 0) { + break label_11; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local2 + (((local6 - local2) + 3) & -4))); + } + label_13: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_13; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + } + return arg0; + } + + public static long[] call_840(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_840(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_841(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(839, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) ((int) callResult_0[0])); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_841(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_841(arg0, memory, instance); + return null; + } + + public static int func_842(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local2 < 0 ? local2 : local2 + 8), arg0) != 0) { + break label_1; + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (long) memory.readLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + local3 = (arg0 + 24); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 35), 0) != 0) { + break label_3; + } + arg1 = (arg1 + 24); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_2; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24)); + callArgs_0[0] = ((long) local3); + instance.getMachine().call(1647, callArgs_0); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (arg0 + 36)); + return 1; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) local2); + instance.getMachine().call(843, callArgs_1); + return 1; + } + + public static long[] call_842(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_842(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_843(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 36); + local5 = (local4 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 119304648) != 0) { + break label_4; + } + local6 = 0; + label_5: { + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local3), 36); + local8 = (local7 << 1); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local5) != 0 ? local8 : local5) : 119304647); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 119304648) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local7 * 36)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local6 = ((int) callResult_0[0]); + } + local5 = (local6 + (local4 * 36)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + local4 = (local7 * 36); + local7 = (local5 + 24); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 35), 0) != 0) { + break label_7; + } + arg1 = (arg1 + 24); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_6; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24)); + callArgs_1[0] = ((long) local7); + instance.getMachine().call(1647, callArgs_1); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + local4 = (local6 + local4); + local8 = (local5 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_2; + } + label_8: while (true) { + local6 = (local5 + -36); + arg1 = (local2 + -36); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) memory.readLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + local7 = (local5 + -12); + local5 = (local2 + -12); + local2 = (local5 + 8); + memory.writeI32((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + local2 = arg1; + local5 = local6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg1) != 0) { + break label_1; + } + arg1 = (arg1 + -12); + label_9: while (true) { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (arg1 + 11) < 0 ? (arg1 + 11) : (arg1 + 11) + 0), -1) != 0) { + break label_10; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_2); + } + local6 = (arg1 + -24); + arg1 = (arg1 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_11; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_5); + } + return; + } + + public static long[] call_843(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_843(arg0, arg1, memory, instance); + return null; + } + + public static void func_844(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + return; + } + + public static long[] call_844(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_844(arg0, arg1, memory, instance); + return null; + } + + public static int func_845(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_845(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_845(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_846(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_846(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_846(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_847(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_847(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_847(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_848(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_848(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_848(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_849(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_849(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_849(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_850(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_850(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_850(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_851(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(((memory.readInt((int) (local2 + 132) < 0 ? (local2 + 132) : (local2 + 132) + 0) - local3) >> 2), arg1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (local2 + 128) < 0 ? (local2 + 128) : (local2 + 128) + 0); + arg1 = (arg1 << 2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local4 = (local4 + ((arg0 - local3) & -4)); + arg1 = local4; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg0) != 0) { + break label_3; + } + arg1 = local4; + label_4: while (true) { + arg1 = (arg1 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 132, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 128, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 124, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_851(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_851(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_852(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 1001) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 15436); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + return 1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg4, 1001) != 0) { + break label_2; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 0); + callArgs_1[1] = ((long) 15392); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_1); + return 1; + } + local6 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local7 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local8 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 40); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local9 = ((int) callResult_3[0]); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 32, (int) 4); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 12, (int) local7); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 4, (long) 0L); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) 47928); + memory.writeLong((int) (local9 + 24) < 0 ? (local9 + 24) : (local9 + 24) + 0, (long) 0L); + memory.writeI32((int) (local9 + 20) < 0 ? (local9 + 20) : (local9 + 20) + 0, (int) local6); + memory.writeI32((int) (local9 + 16) < 0 ? (local9 + 16) : (local9 + 16) + 0, (int) local8); + local7 = 0; + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 108); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local6 = ((int) callResult_4[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 36, (int) 0); + memory.writeByte((int) local6 < 0 ? local6 : local6 + 35, (byte) (0)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 4, (long) 0L); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 40, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 48148); + memory.writeByte((int) local6 < 0 ? local6 : local6 + 104, (byte) (0)); + memory.writeLong((int) (local6 + 12) < 0 ? (local6 + 12) : (local6 + 12) + 0, (long) 0L); + memory.writeLong((int) (local6 + 17) < 0 ? (local6 + 17) : (local6 + 17) + 0, (long) 0L); + memory.writeLong((int) (local6 + 48) < 0 ? (local6 + 48) : (local6 + 48) + 0, (long) 0L); + local10 = (local6 + 56); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 0, (long) 0L); + memory.writeLong((int) (local6 + 64) < 0 ? (local6 + 64) : (local6 + 64) + 0, (long) 0L); + memory.writeLong((int) (local6 + 72) < 0 ? (local6 + 72) : (local6 + 72) + 0, (long) 0L); + memory.writeLong((int) (local6 + 84) < 0 ? (local6 + 84) : (local6 + 84) + 0, (long) 0L); + memory.writeI32((int) (local6 + 80) < 0 ? (local6 + 80) : (local6 + 80) + 0, (int) 1065353216); + memory.writeLong((int) (local6 + 92) < 0 ? (local6 + 92) : (local6 + 92) + 0, (long) 0L); + memory.writeI32((int) (local6 + 100) < 0 ? (local6 + 100) : (local6 + 100) + 0, (int) 1065353216); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (arg3 + (arg2 << 3))); + callArgs_5[1] = ((long) arg3); + callArgs_5[0] = ((long) (local6 + 40)); + instance.getMachine().call(344, callArgs_5); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) (arg5 + (arg4 << 3))); + callArgs_6[1] = ((long) arg5); + callArgs_6[0] = ((long) (local6 + 52)); + instance.getMachine().call(344, callArgs_6); + label_3: { + label_4: { + arg4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + arg5 = memory.readInt((int) (local6 + 44) < 0 ? (local6 + 44) : (local6 + 44) + 0); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg5, arg4); + if (local8 != 0) { + break label_4; + } + arg2 = arg4; + label_5: { + label_6: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-5, memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)) != 0) { + break label_5; + } + arg2 = (arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg5, arg2) != 0) { + break label_4; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + } + local7 = 1; + break label_3; + } + arg2 = memory.readInt((int) local6 < 0 ? local6 : local6 + 52); + arg3 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg3, arg2) != 0) { + break label_3; + } + label_7: while (true) { + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-5, memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + if (local7 != 0) { + break label_3; + } + arg2 = (arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg3, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 388, (byte) ((((int) memory.read((int) arg3 < 0 ? arg3 : arg3 + 388) & 0xFF) | local7))); + label_8: { + label_9: { + if (local8 != 0) { + break label_9; + } + label_10: { + label_11: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-23, memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 0)) != 0) { + break label_10; + } + arg4 = (arg4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg5, arg4) != 0) { + break label_9; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + } + arg4 = 1; + break label_8; + } + label_12: { + arg2 = memory.readInt((int) local6 < 0 ? local6 : local6 + 52); + arg5 = memory.readInt((int) (local6 + 56) < 0 ? (local6 + 56) : (local6 + 56) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg5, arg2) != 0) { + break label_12; + } + arg4 = 0; + break label_8; + } + label_13: while (true) { + arg4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-23, memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + if (arg4 != 0) { + break label_8; + } + arg2 = (arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg5, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break; + } + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 36, (int) local6); + arg2 = (arg3 + 389); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 0, (byte) ((((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF) | arg4))); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local9); + callArgs_7[0] = ((long) arg3); + instance.getMachine().call(143, callArgs_7); + return 0; + } + + public static long[] call_852(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int result = Wat2WasmMachine.func_852(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_853(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 192); + instance.global(0).setValue(((long) local3)); + local4 = local3; + memory.writeI32((int) local4 < 0 ? local4 : local4 + 164, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 160, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) (local4 + 32)); + local5 = (local4 + 32); + label_1: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 128); + callArgs_0[0] = ((long) (local4 + 32)); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg2 = (((int) callResult_0[0]) + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 129) != 0) { + break label_1; + } + local5 = (local3 - ((arg2 + 15) & -16)); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) local5); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 160)); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1875, callArgs_1); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) 1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) -1); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + label_2: { + label_3: { + label_4: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)) != 0) { + break label_4; + } + arg0 = ((local4 + 168) + 16); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) memory.readInt((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + local6 = ((local4 + 168) + 8); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 168, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local3 = ((int) callResult_2[0]); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 1); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 168)); + memory.writeLong((int) (arg2 + 12) < 0 ? (arg2 + 12) : (arg2 + 12) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_2; + } + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_6; + } + arg0 = (arg2 + 24); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 35, (byte) (local3)); + break label_5; + } + local6 = ((local3 | 15) + 1); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg0 = ((int) callResult_3[0]); + memory.writeI32((int) (arg2 + 32) < 0 ? (arg2 + 32) : (arg2 + 32) + 0, (int) (local6 | -2147483648)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 24, (int) arg0); + memory.writeI32((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (int) local3); + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local3); + callArgs_4[1] = ((long) local5); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1891, callArgs_4); + memory.writeByte((int) (((int) callResult_4[0]) + local3) < 0 ? (((int) callResult_4[0]) + local3) : (((int) callResult_4[0]) + local3) + 0, (byte) (0)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (arg2 + 36)); + break label_3; + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local4 + 28)); + callArgs_5[2] = ((long) local4); + callArgs_5[1] = ((long) (local4 + 24)); + callArgs_5[0] = ((long) arg1); + instance.getMachine().call(1086, callArgs_5); + } + instance.global(0).setValue(((long) (local4 + 192))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_853(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_853(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_854(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local4 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local6 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 40); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local5); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 32, (long) 4L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 47928); + memory.writeLong((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0, (long) 0L); + memory.writeI32((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (int) local4); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) local6); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 52); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local8 = ((int) callResult_2[0]); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 4, (long) 0L); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 35, (byte) (0)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 36, (int) 1); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 40, (long) 0L); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) 50792); + memory.writeLong((int) (local8 + 12) < 0 ? (local8 + 12) : (local8 + 12) + 0, (long) 0L); + memory.writeLong((int) (local8 + 17) < 0 ? (local8 + 17) : (local8 + 17) + 0, (long) 0L); + memory.writeI32((int) (local8 + 48) < 0 ? (local8 + 48) : (local8 + 48) + 0, (int) 0); + label_1: { + label_2: { + if (arg2 != 0) { + break label_2; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 36, (int) local8); + break label_1; + } + local9 = (local8 + 40); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) local9); + instance.getMachine().call(855, callArgs_3); + local6 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + local4 = 12; + label_3: while (true) { + memory.writeLong((int) (local6 + local4) < 0 ? (local6 + local4) : (local6 + local4) + 0, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + local6 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + memory.writeByte((int) ((local6 + local4) + 8) < 0 ? ((local6 + local4) + 8) : ((local6 + local4) + 8) + 0, (byte) (((int) memory.read((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0) & 0xFF))); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local10 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 388, (byte) ((((int) memory.read((int) local5 < 0 ? local5 : local5 + 388) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-5, local10)))); + local5 = (local5 + 389); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) ((((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-23, local10)))); + local4 = (local4 + 24); + arg3 = (arg3 + 12); + arg2 = (arg2 + -1); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + arg3 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 36, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0) < 0 ? memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0) : memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg3); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local7); + callArgs_5[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + instance.getMachine().call(143, callArgs_5); + return 0; + } + + public static long[] call_854(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_854(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_855(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 24), arg1) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + local4 = (arg1 * 24); + local2 = local3; + label_3: { + local5 = ((arg1 * 24) + -24); + local6 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local5, 24) + 1) & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + local6 = (local6 * 24); + local2 = local3; + label_4: while (true) { + arg1 = (local2 + 16); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) 0L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) -1); + memory.writeI32((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0, (int) -64); + local2 = (local2 + 24); + local6 = (local6 + -24); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + local3 = (local3 + local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 168) != 0) { + break label_2; + } + label_5: while (true) { + local6 = (local2 + 16); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) 0L); + memory.writeLong((int) (local2 + 32) < 0 ? (local2 + 32) : (local2 + 32) + 0, (long) 0L); + arg1 = (local2 + 40); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + memory.writeLong((int) (local2 + 56) < 0 ? (local2 + 56) : (local2 + 56) + 0, (long) 0L); + local4 = (local2 + 64); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeLong((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0, (long) 0L); + memory.writeLong((int) (local2 + 88) < 0 ? (local2 + 88) : (local2 + 88) + 0, (long) 0L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + memory.writeLong((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (long) 0L); + memory.writeLong((int) (local2 + 48) < 0 ? (local2 + 48) : (local2 + 48) + 0, (long) 0L); + memory.writeLong((int) (local2 + 72) < 0 ? (local2 + 72) : (local2 + 72) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) -1); + memory.writeI32((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0, (int) -64); + memory.writeI32((int) (local2 + 36) < 0 ? (local2 + 36) : (local2 + 36) + 0, (int) -64); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) -1); + memory.writeI32((int) (local2 + 60) < 0 ? (local2 + 60) : (local2 + 60) + 0, (int) -64); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) -1); + memory.writeLong((int) (local2 + 84) < 0 ? (local2 + 84) : (local2 + 84) + 0, (long) -64L); + memory.writeLong((int) (local2 + 112) < 0 ? (local2 + 112) : (local2 + 112) + 0, (long) 0L); + memory.writeLong((int) (local2 + 104) < 0 ? (local2 + 104) : (local2 + 104) + 0, (long) 0L); + memory.writeLong((int) (local2 + 96) < 0 ? (local2 + 96) : (local2 + 96) + 0, (long) 0L); + memory.writeLong((int) (local2 + 108) < 0 ? (local2 + 108) : (local2 + 108) + 0, (long) -64L); + memory.writeLong((int) (local2 + 136) < 0 ? (local2 + 136) : (local2 + 136) + 0, (long) 0L); + memory.writeLong((int) (local2 + 128) < 0 ? (local2 + 128) : (local2 + 128) + 0, (long) 0L); + memory.writeLong((int) (local2 + 120) < 0 ? (local2 + 120) : (local2 + 120) + 0, (long) 0L); + memory.writeLong((int) (local2 + 132) < 0 ? (local2 + 132) : (local2 + 132) + 0, (long) -64L); + memory.writeLong((int) (local2 + 160) < 0 ? (local2 + 160) : (local2 + 160) + 0, (long) 0L); + memory.writeLong((int) (local2 + 152) < 0 ? (local2 + 152) : (local2 + 152) + 0, (long) 0L); + memory.writeLong((int) (local2 + 144) < 0 ? (local2 + 144) : (local2 + 144) + 0, (long) 0L); + memory.writeLong((int) (local2 + 156) < 0 ? (local2 + 156) : (local2 + 156) + 0, (long) -64L); + memory.writeLong((int) (local2 + 184) < 0 ? (local2 + 184) : (local2 + 184) + 0, (long) 0L); + memory.writeLong((int) (local2 + 176) < 0 ? (local2 + 176) : (local2 + 176) + 0, (long) 0L); + memory.writeLong((int) (local2 + 168) < 0 ? (local2 + 168) : (local2 + 168) + 0, (long) 0L); + memory.writeLong((int) (local2 + 180) < 0 ? (local2 + 180) : (local2 + 180) + 0, (long) -64L); + local2 = (local2 + 192); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + return; + } + label_6: { + label_7: { + label_8: { + label_9: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 24); + local6 = (local5 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 178956971) != 0) { + break label_9; + } + label_10: { + label_11: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local4), 24); + local4 = (local2 << 1); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 89478485) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, local6) != 0 ? local4 : local6) : 178956970); + if (local7 != 0) { + break label_11; + } + local8 = 0; + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 178956971) != 0) { + break label_8; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local7 * 24)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local8 = ((int) callResult_0[0]); + } + local6 = (local8 + (local5 * 24)); + local2 = local6; + label_12: { + local5 = (arg1 * 24); + local9 = (local5 + -24); + arg1 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local9, 24) + 1) & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_12; + } + arg1 = (arg1 * 24); + local2 = local6; + label_13: while (true) { + local4 = (local2 + 16); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) 0L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) -1); + memory.writeI32((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0, (int) -64); + local2 = (local2 + 24); + arg1 = (arg1 + -24); + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break; + } + } + local10 = (local6 + local5); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, 168) != 0) { + break label_14; + } + label_15: while (true) { + arg1 = (local2 + 16); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) 0L); + memory.writeLong((int) (local2 + 32) < 0 ? (local2 + 32) : (local2 + 32) + 0, (long) 0L); + local4 = (local2 + 40); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeLong((int) (local2 + 56) < 0 ? (local2 + 56) : (local2 + 56) + 0, (long) 0L); + local5 = (local2 + 64); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeLong((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0, (long) 0L); + memory.writeLong((int) (local2 + 88) < 0 ? (local2 + 88) : (local2 + 88) + 0, (long) 0L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + memory.writeLong((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (long) 0L); + memory.writeLong((int) (local2 + 48) < 0 ? (local2 + 48) : (local2 + 48) + 0, (long) 0L); + memory.writeLong((int) (local2 + 72) < 0 ? (local2 + 72) : (local2 + 72) + 0, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) -1); + memory.writeI32((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0, (int) -64); + memory.writeI32((int) (local2 + 36) < 0 ? (local2 + 36) : (local2 + 36) + 0, (int) -64); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) -1); + memory.writeI32((int) (local2 + 60) < 0 ? (local2 + 60) : (local2 + 60) + 0, (int) -64); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) -1); + memory.writeLong((int) (local2 + 84) < 0 ? (local2 + 84) : (local2 + 84) + 0, (long) -64L); + memory.writeLong((int) (local2 + 112) < 0 ? (local2 + 112) : (local2 + 112) + 0, (long) 0L); + memory.writeLong((int) (local2 + 104) < 0 ? (local2 + 104) : (local2 + 104) + 0, (long) 0L); + memory.writeLong((int) (local2 + 96) < 0 ? (local2 + 96) : (local2 + 96) + 0, (long) 0L); + memory.writeLong((int) (local2 + 108) < 0 ? (local2 + 108) : (local2 + 108) + 0, (long) -64L); + memory.writeLong((int) (local2 + 136) < 0 ? (local2 + 136) : (local2 + 136) + 0, (long) 0L); + memory.writeLong((int) (local2 + 128) < 0 ? (local2 + 128) : (local2 + 128) + 0, (long) 0L); + memory.writeLong((int) (local2 + 120) < 0 ? (local2 + 120) : (local2 + 120) + 0, (long) 0L); + memory.writeLong((int) (local2 + 132) < 0 ? (local2 + 132) : (local2 + 132) + 0, (long) -64L); + memory.writeLong((int) (local2 + 160) < 0 ? (local2 + 160) : (local2 + 160) + 0, (long) 0L); + memory.writeLong((int) (local2 + 152) < 0 ? (local2 + 152) : (local2 + 152) + 0, (long) 0L); + memory.writeLong((int) (local2 + 144) < 0 ? (local2 + 144) : (local2 + 144) + 0, (long) 0L); + memory.writeLong((int) (local2 + 156) < 0 ? (local2 + 156) : (local2 + 156) + 0, (long) -64L); + memory.writeLong((int) (local2 + 184) < 0 ? (local2 + 184) : (local2 + 184) + 0, (long) 0L); + memory.writeLong((int) (local2 + 176) < 0 ? (local2 + 176) : (local2 + 176) + 0, (long) 0L); + memory.writeLong((int) (local2 + 168) < 0 ? (local2 + 168) : (local2 + 168) + 0, (long) 0L); + memory.writeLong((int) (local2 + 180) < 0 ? (local2 + 180) : (local2 + 180) + 0, (long) -64L); + local2 = (local2 + 192); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local10, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_15; + } + break; + } + } + local7 = (local8 + (local7 * 24)); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local3) != 0) { + break label_7; + } + label_16: while (true) { + arg1 = (local6 + -24); + local2 = (local3 + -24); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + local4 = (local2 + 8); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + local6 = (local6 + -12); + local3 = (local3 + -12); + memory.writeByte((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (byte) (((int) memory.read((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0) & 0xFF))); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + local3 = local2; + local6 = arg1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local10); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_6; + } + local2 = (local2 + -24); + label_17: while (true) { + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + 11) < 0 ? (local2 + 11) : (local2 + 11) + 0), -1) != 0) { + break label_18; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_1); + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2); + local2 = (local2 + -24); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_17; + } + break label_6; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_19; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_4); + } + return; + } + + public static long[] call_855(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_855(arg0, arg1, memory, instance); + return null; + } + + public static int func_856(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 40); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local6 = ((int) callResult_1[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) 4); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) local4); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 4, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 47928); + memory.writeLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0, (long) 0L); + memory.writeI32((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0, (int) local3); + memory.writeI32((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (int) local5); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 64); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local3 = ((int) callResult_2[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 35, (byte) (0)); + memory.writeLong((int) (local3 + 17) < 0 ? (local3 + 17) : (local3 + 17) + 0, (long) 0L); + memory.writeLong((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0, (long) 0L); + memory.writeI32((int) (local3 + 48) < 0 ? (local3 + 48) : (local3 + 48) + 0, (int) 0); + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) (local3 + 52) < 0 ? (local3 + 52) : (local3 + 52) + 0, (long) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) 2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 50840); + memory.writeByte((int) (local3 + 60) < 0 ? (local3 + 60) : (local3 + 60) + 0, (byte) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 8) & 0xFF))); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg2 = (int) local7; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 388, (byte) ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 388) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-5, arg2)))); + local4 = (arg0 + 389); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) ((((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-23, arg2)))); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 36, (int) local3); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local6); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(143, callArgs_3); + return 0; + } + + public static long[] call_856(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_856(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_857(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_857(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_857(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_858(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_858(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_858(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_859(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 100); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(((memory.readInt((int) (local2 + 108) < 0 ? (local2 + 108) : (local2 + 108) + 0) - local3) >> 2), arg1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (local2 + 104) < 0 ? (local2 + 104) : (local2 + 104) + 0); + arg1 = (arg1 << 2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local4 = (local4 + ((arg0 - local3) & -4)); + arg1 = local4; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg0) != 0) { + break label_3; + } + arg1 = local4; + label_4: while (true) { + arg1 = (arg1 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 108, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 104, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 100, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_859(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_859(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_860(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_860(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_860(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_861(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + long local8 = 0L; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local6 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local6)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 216); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 50568); + memory.writeShort((int) local7 < 0 ? local7 : local7 + 43, (short) (0)); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 32, (byte) (0)); + memory.writeI32((int) (local7 + 28) < 0 ? (local7 + 28) : (local7 + 28) + 0, (int) 0); + memory.writeLong((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (long) 0L); + memory.writeLong((int) (local7 + 12) < 0 ? (local7 + 12) : (local7 + 12) + 0, (long) 0L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local7 + 48)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local7 + 116) < 0 ? (local7 + 116) : (local7 + 116) + 0, (long) 0L); + memory.writeLong((int) (local7 + 108) < 0 ? (local7 + 108) : (local7 + 108) + 0, (long) 0L); + memory.writeLong((int) (local7 + 100) < 0 ? (local7 + 100) : (local7 + 100) + 0, (long) 0L); + memory.writeLong((int) (local7 + 92) < 0 ? (local7 + 92) : (local7 + 92) + 0, (long) 0L); + memory.writeLong((int) (local7 + 84) < 0 ? (local7 + 84) : (local7 + 84) + 0, (long) 0L); + memory.writeLong((int) (local7 + 128) < 0 ? (local7 + 128) : (local7 + 128) + 0, (long) 0L); + memory.writeI32((int) (local7 + 124) < 0 ? (local7 + 124) : (local7 + 124) + 0, (int) 1065353216); + memory.writeLong((int) (local7 + 136) < 0 ? (local7 + 136) : (local7 + 136) + 0, (long) 0L); + memory.writeLong((int) (local7 + 148) < 0 ? (local7 + 148) : (local7 + 148) + 0, (long) 0L); + memory.writeI32((int) (local7 + 144) < 0 ? (local7 + 144) : (local7 + 144) + 0, (int) 1065353216); + memory.writeLong((int) (local7 + 156) < 0 ? (local7 + 156) : (local7 + 156) + 0, (long) 0L); + memory.writeLong((int) (local7 + 164) < 0 ? (local7 + 164) : (local7 + 164) + 0, (long) 0L); + memory.writeLong((int) (local7 + 180) < 0 ? (local7 + 180) : (local7 + 180) + 0, (long) 0L); + memory.writeLong((int) (local7 + 172) < 0 ? (local7 + 172) : (local7 + 172) + 0, (long) 4575657221408423936L); + memory.writeLong((int) (local7 + 188) < 0 ? (local7 + 188) : (local7 + 188) + 0, (long) 0L); + memory.writeLong((int) (local7 + 196) < 0 ? (local7 + 196) : (local7 + 196) + 0, (long) 0L); + memory.writeLong((int) (local7 + 204) < 0 ? (local7 + 204) : (local7 + 204) + 0, (long) 0L); + memory.writeByte((int) (local7 + 212) < 0 ? (local7 + 212) : (local7 + 212) + 0, (byte) (0)); + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (int) (local8 >>> 32L)); + callArgs_2[1] = ((long) (int) local8); + callArgs_2[0] = ((long) (local7 + 4)); + long[] callResult_2 = instance.getMachine().call(1649, callArgs_2); + local8 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (int) (local8 >>> 32L)); + callArgs_3[1] = ((long) (int) local8); + callArgs_3[0] = ((long) (local7 + 16)); + long[] callResult_3 = instance.getMachine().call(1649, callArgs_3); + arg2 = (arg0 + 4); + arg3 = memory.readInt((int) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) < 0 ? (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) : (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) + 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 12, (long) 0L); + local9 = (arg0 + 32); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local10); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local11 = ((int) callResult_4[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg3); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local11); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local10); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local6); + callArgs_5[1] = ((long) arg5); + callArgs_5[0] = ((long) (local6 + 24)); + long[] callResult_5 = instance.getMachine().call(155, callArgs_5); + arg3 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) arg3); + callArgs_6[1] = ((long) (local7 + 44)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(862, callArgs_6); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg3); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + arg2 = memory.readInt((int) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) < 0 ? (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) : (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) + 0); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg5 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg5); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local9 = ((int) callResult_8[0]); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) 40); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + arg0 = ((int) callResult_9[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg5); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50208); + memory.writeLong((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0, (long) 0L); + memory.writeI32((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (int) arg2); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) local9); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) arg0); + callArgs_10[0] = ((long) arg3); + instance.getMachine().call(145, callArgs_10); + instance.global(0).setValue(((long) (local6 + 64))); + return 0; + } + + public static long[] call_861(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int result = Wat2WasmMachine.func_861(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_862(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (1)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (arg1 + 4)); + long[] callResult_0 = instance.getMachine().call(160, callArgs_0); + label_1: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + long[] callResult_1 = instance.getMachine().call(133, callArgs_1); + arg2 = ((int) callResult_1[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg1) != 0) { + break label_1; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) memory.readInt((int) (arg2 + 44) < 0 ? (arg2 + 44) : (arg2 + 44) + 0)); + callArgs_2[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 40)); + callArgs_2[0] = ((long) (arg1 + 40)); + instance.getMachine().call(344, callArgs_2); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) memory.readInt((int) (arg2 + 56) < 0 ? (arg2 + 56) : (arg2 + 56) + 0)); + callArgs_3[1] = ((long) memory.readInt((int) (arg2 + 52) < 0 ? (arg2 + 52) : (arg2 + 52) + 0)); + callArgs_3[0] = ((long) (arg1 + 52)); + instance.getMachine().call(344, callArgs_3); + memory.writeF32((int) (arg1 + 80) < 0 ? (arg1 + 80) : (arg1 + 80) + 0, (float) memory.readFloat((int) (arg2 + 80) < 0 ? (arg2 + 80) : (arg2 + 80) + 0)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) memory.readInt((int) (arg2 + 72) < 0 ? (arg2 + 72) : (arg2 + 72) + 0)); + callArgs_4[0] = ((long) (arg1 + 64)); + instance.getMachine().call(1304, callArgs_4); + memory.writeF32((int) (arg1 + 100) < 0 ? (arg1 + 100) : (arg1 + 100) + 0, (float) memory.readFloat((int) (arg2 + 100) < 0 ? (arg2 + 100) : (arg2 + 100) + 0)); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 0); + callArgs_5[1] = ((long) memory.readInt((int) (arg2 + 92) < 0 ? (arg2 + 92) : (arg2 + 92) + 0)); + callArgs_5[0] = ((long) (arg1 + 84)); + instance.getMachine().call(1304, callArgs_5); + } + return; + } + + public static long[] call_862(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_862(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_863(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + long local12 = 0L; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 80); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) 1); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 43, (byte) (0)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 51116); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 32, (byte) (0)); + memory.writeLong((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (long) 0L); + memory.writeLong((int) (local7 + 12) < 0 ? (local7 + 12) : (local7 + 12) + 0, (long) 0L); + local8 = (local7 + 48); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + local9 = (local7 + 56); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) 0L); + local10 = (local7 + 63); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) 0); + local11 = (local7 + 72); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) -16L); + local12 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (int) (local12 >>> 32L)); + callArgs_1[1] = ((long) (int) local12); + callArgs_1[0] = ((long) (local7 + 4)); + long[] callResult_1 = instance.getMachine().call(1649, callArgs_1); + local12 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (int) (local12 >>> 32L)); + callArgs_2[1] = ((long) (int) local12); + callArgs_2[0] = ((long) (local7 + 16)); + long[] callResult_2 = instance.getMachine().call(1649, callArgs_2); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) memory.readInt((int) (arg6 + 15) < 0 ? (arg6 + 15) : (arg6 + 15) + 0)); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) memory.readLong((int) (arg6 + 8) < 0 ? (arg6 + 8) : (arg6 + 8) + 0)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) arg6 < 0 ? arg6 : arg6 + 0)); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) memory.readLong((int) arg5 < 0 ? arg5 : arg5 + 0)); + arg2 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + arg5 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 40); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg6 = ((int) callResult_4[0]); + memory.writeI32((int) arg6 < 0 ? arg6 : arg6 + 32, (int) 2); + memory.writeI32((int) arg6 < 0 ? arg6 : arg6 + 12, (int) arg0); + memory.writeLong((int) arg6 < 0 ? arg6 : arg6 + 4, (long) 0L); + memory.writeI32((int) arg6 < 0 ? arg6 : arg6 + 36, (int) local7); + memory.writeI32((int) arg6 < 0 ? arg6 : arg6 + 0, (int) 50208); + memory.writeLong((int) (arg6 + 24) < 0 ? (arg6 + 24) : (arg6 + 24) + 0, (long) 0L); + memory.writeI32((int) (arg6 + 20) < 0 ? (arg6 + 20) : (arg6 + 20) + 0, (int) arg2); + memory.writeI32((int) (arg6 + 16) < 0 ? (arg6 + 16) : (arg6 + 16) + 0, (int) arg5); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg6); + callArgs_5[0] = ((long) arg3); + instance.getMachine().call(145, callArgs_5); + return 0; + } + + public static long[] call_863(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int result = Wat2WasmMachine.func_863(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_864(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + long local11 = 0L; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 80); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) 2); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 43, (byte) (0)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 51224); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 32, (byte) (0)); + memory.writeLong((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (long) 0L); + memory.writeLong((int) (local7 + 12) < 0 ? (local7 + 12) : (local7 + 12) + 0, (long) 0L); + local8 = (local7 + 48); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + local9 = (local7 + 56); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) 0L); + local10 = (local7 + 63); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) 0); + local11 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (int) (local11 >>> 32L)); + callArgs_1[1] = ((long) (int) local11); + callArgs_1[0] = ((long) (local7 + 4)); + long[] callResult_1 = instance.getMachine().call(1649, callArgs_1); + local11 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (int) (local11 >>> 32L)); + callArgs_2[1] = ((long) (int) local11); + callArgs_2[0] = ((long) (local7 + 16)); + long[] callResult_2 = instance.getMachine().call(1649, callArgs_2); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) memory.readInt((int) (arg5 + 15) < 0 ? (arg5 + 15) : (arg5 + 15) + 0)); + memory.writeI32((int) (local7 + 72) < 0 ? (local7 + 72) : (local7 + 72) + 0, (int) arg6); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) memory.readLong((int) (arg5 + 8) < 0 ? (arg5 + 8) : (arg5 + 8) + 0)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) arg5 < 0 ? arg5 : arg5 + 0)); + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (local7 + 65) < 0 ? (local7 + 65) : (local7 + 65) + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (arg2 + 390) < 0 ? (arg2 + 390) : (arg2 + 390) + 0, (byte) (1)); + } + arg3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + arg0 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + arg6 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 40); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg5 = ((int) callResult_4[0]); + memory.writeI32((int) arg5 < 0 ? arg5 : arg5 + 32, (int) 2); + memory.writeI32((int) arg5 < 0 ? arg5 : arg5 + 12, (int) arg0); + memory.writeLong((int) arg5 < 0 ? arg5 : arg5 + 4, (long) 0L); + memory.writeI32((int) arg5 < 0 ? arg5 : arg5 + 36, (int) local7); + memory.writeI32((int) arg5 < 0 ? arg5 : arg5 + 0, (int) 50208); + memory.writeLong((int) (arg5 + 24) < 0 ? (arg5 + 24) : (arg5 + 24) + 0, (long) 0L); + memory.writeI32((int) (arg5 + 20) < 0 ? (arg5 + 20) : (arg5 + 20) + 0, (int) arg3); + memory.writeI32((int) (arg5 + 16) < 0 ? (arg5 + 16) : (arg5 + 16) + 0, (int) arg6); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg5); + callArgs_5[0] = ((long) arg2); + instance.getMachine().call(145, callArgs_5); + return 0; + } + + public static long[] call_864(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int result = Wat2WasmMachine.func_864(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_865(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 68); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) 3); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 43, (byte) (0)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 50888); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 32, (byte) (0)); + memory.writeLong((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (long) 0L); + memory.writeLong((int) (local7 + 12) < 0 ? (local7 + 12) : (local7 + 12) + 0, (long) 0L); + memory.writeI32((int) (local7 + 64) < 0 ? (local7 + 64) : (local7 + 64) + 0, (int) 0); + memory.writeLong((int) (local7 + 56) < 0 ? (local7 + 56) : (local7 + 56) + 0, (long) 0L); + local8 = (local7 + 52); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 0, (byte) (0)); + local9 = (local7 + 44); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) -64L); + local10 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (int) (local10 >>> 32L)); + callArgs_1[1] = ((long) (int) local10); + callArgs_1[0] = ((long) (local7 + 4)); + long[] callResult_1 = instance.getMachine().call(1649, callArgs_1); + local10 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (int) (local10 >>> 32L)); + callArgs_2[1] = ((long) (int) local10); + callArgs_2[0] = ((long) (local7 + 16)); + long[] callResult_2 = instance.getMachine().call(1649, callArgs_2); + local10 = memory.readLong((int) arg5 < 0 ? arg5 : arg5 + 0); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) local10); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 0, (byte) (arg6)); + arg3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + arg5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg6 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg6); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local8 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 40); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg2 = ((int) callResult_4[0]); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 32, (int) 2); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 12, (int) arg6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 36, (int) local7); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 50208); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0, (int) arg3); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local8); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) arg5); + instance.getMachine().call(145, callArgs_5); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg2 = (int) local10; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 388, (byte) ((((int) memory.read((int) local7 < 0 ? local7 : local7 + 388) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-5, arg2)))); + local7 = (local7 + 389); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 0, (byte) ((((int) memory.read((int) local7 < 0 ? local7 : local7 + 0) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-23, arg2)))); + return 0; + } + + public static long[] call_865(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int result = Wat2WasmMachine.func_865(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_866(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + long local8 = 0L; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local6 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local6)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 148); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) 4); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 50064); + memory.writeShort((int) local7 < 0 ? local7 : local7 + 43, (short) (0)); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 32, (byte) (0)); + memory.writeLong((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (long) 0L); + memory.writeLong((int) (local7 + 12) < 0 ? (local7 + 12) : (local7 + 12) + 0, (long) 0L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local7 + 48)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local7 + 116) < 0 ? (local7 + 116) : (local7 + 116) + 0, (long) 0L); + memory.writeLong((int) (local7 + 108) < 0 ? (local7 + 108) : (local7 + 108) + 0, (long) 0L); + memory.writeLong((int) (local7 + 100) < 0 ? (local7 + 100) : (local7 + 100) + 0, (long) 0L); + memory.writeLong((int) (local7 + 92) < 0 ? (local7 + 92) : (local7 + 92) + 0, (long) 0L); + memory.writeLong((int) (local7 + 84) < 0 ? (local7 + 84) : (local7 + 84) + 0, (long) 0L); + memory.writeLong((int) (local7 + 128) < 0 ? (local7 + 128) : (local7 + 128) + 0, (long) 0L); + memory.writeI32((int) (local7 + 124) < 0 ? (local7 + 124) : (local7 + 124) + 0, (int) 1065353216); + memory.writeLong((int) (local7 + 136) < 0 ? (local7 + 136) : (local7 + 136) + 0, (long) 0L); + memory.writeI32((int) (local7 + 144) < 0 ? (local7 + 144) : (local7 + 144) + 0, (int) 1065353216); + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (int) (local8 >>> 32L)); + callArgs_2[1] = ((long) (int) local8); + callArgs_2[0] = ((long) (local7 + 4)); + long[] callResult_2 = instance.getMachine().call(1649, callArgs_2); + local8 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (int) (local8 >>> 32L)); + callArgs_3[1] = ((long) (int) local8); + callArgs_3[0] = ((long) (local7 + 16)); + long[] callResult_3 = instance.getMachine().call(1649, callArgs_3); + arg2 = (arg0 + 4); + arg3 = memory.readInt((int) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) < 0 ? (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) : (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) + 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 12, (long) 0L); + local9 = (arg0 + 32); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local10); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local11 = ((int) callResult_4[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg3); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local11); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local10); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local6); + callArgs_5[1] = ((long) arg5); + callArgs_5[0] = ((long) (local6 + 24)); + long[] callResult_5 = instance.getMachine().call(155, callArgs_5); + arg3 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) arg3); + callArgs_6[1] = ((long) (local7 + 44)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(862, callArgs_6); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg3); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + arg3 = memory.readInt((int) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) < 0 ? (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) : (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 8) + 0); + arg5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local9 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local9); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local10 = ((int) callResult_8[0]); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) 40); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + arg2 = ((int) callResult_9[0]); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 32, (int) 2); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 12, (int) local9); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 36, (int) local7); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 50208); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0, (int) arg3); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local10); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) arg2); + callArgs_10[0] = ((long) arg5); + instance.getMachine().call(145, callArgs_10); + memory.writeByte((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) + 0, (byte) (1)); + instance.global(0).setValue(((long) (local6 + 64))); + return 0; + } + + public static long[] call_866(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int result = Wat2WasmMachine.func_866(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_867(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_867(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_867(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_868(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_868(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_868(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_869(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 76); + arg1 = (memory.readInt((int) local2 < 0 ? local2 : local2 + 48) + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(((memory.readInt((int) (local2 + 84) < 0 ? (local2 + 84) : (local2 + 84) + 0) - local3) >> 2), arg1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0); + arg1 = (arg1 << 2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local4 = (local4 + ((arg0 - local3) & -4)); + arg1 = local4; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg0) != 0) { + break label_3; + } + arg1 = local4; + label_4: while (true) { + arg1 = (arg1 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 76, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_869(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_869(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_870(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + local4 = (arg0 + 4); + local5 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + local6 = (arg0 + 32); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local8 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 220); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local9 = ((int) callResult_1[0]); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 32, (int) 0); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 12, (int) local7); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 4, (long) 0L); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) 50672); + memory.writeShort((int) local9 < 0 ? local9 : local9 + 47, (short) (0)); + memory.writeByte((int) local9 < 0 ? local9 : local9 + 36, (byte) (0)); + memory.writeLong((int) (local9 + 24) < 0 ? (local9 + 24) : (local9 + 24) + 0, (long) 0L); + memory.writeI32((int) (local9 + 20) < 0 ? (local9 + 20) : (local9 + 20) + 0, (int) local5); + memory.writeI32((int) (local9 + 16) < 0 ? (local9 + 16) : (local9 + 16) + 0, (int) local8); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local9 + 52)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + memory.writeLong((int) (local9 + 120) < 0 ? (local9 + 120) : (local9 + 120) + 0, (long) 0L); + memory.writeLong((int) (local9 + 112) < 0 ? (local9 + 112) : (local9 + 112) + 0, (long) 0L); + memory.writeLong((int) (local9 + 104) < 0 ? (local9 + 104) : (local9 + 104) + 0, (long) 0L); + memory.writeLong((int) (local9 + 96) < 0 ? (local9 + 96) : (local9 + 96) + 0, (long) 0L); + memory.writeLong((int) (local9 + 88) < 0 ? (local9 + 88) : (local9 + 88) + 0, (long) 0L); + memory.writeLong((int) (local9 + 132) < 0 ? (local9 + 132) : (local9 + 132) + 0, (long) 0L); + memory.writeI32((int) (local9 + 128) < 0 ? (local9 + 128) : (local9 + 128) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 140) < 0 ? (local9 + 140) : (local9 + 140) + 0, (long) 0L); + memory.writeLong((int) (local9 + 152) < 0 ? (local9 + 152) : (local9 + 152) + 0, (long) 0L); + memory.writeI32((int) (local9 + 148) < 0 ? (local9 + 148) : (local9 + 148) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 160) < 0 ? (local9 + 160) : (local9 + 160) + 0, (long) 0L); + memory.writeLong((int) (local9 + 168) < 0 ? (local9 + 168) : (local9 + 168) + 0, (long) 0L); + memory.writeLong((int) (local9 + 184) < 0 ? (local9 + 184) : (local9 + 184) + 0, (long) 0L); + memory.writeLong((int) (local9 + 176) < 0 ? (local9 + 176) : (local9 + 176) + 0, (long) 4575657221408423936L); + memory.writeLong((int) (local9 + 192) < 0 ? (local9 + 192) : (local9 + 192) + 0, (long) 0L); + memory.writeLong((int) (local9 + 200) < 0 ? (local9 + 200) : (local9 + 200) + 0, (long) 0L); + memory.writeLong((int) (local9 + 208) < 0 ? (local9 + 208) : (local9 + 208) + 0, (long) 0L); + memory.writeByte((int) (local9 + 216) < 0 ? (local9 + 216) : (local9 + 216) + 0, (byte) (0)); + local4 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) 0L); + local5 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local5); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local6 = ((int) callResult_3[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local5); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local3); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local3 + 24)); + long[] callResult_4 = instance.getMachine().call(155, callArgs_4); + arg2 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) (local9 + 48)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(862, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg2); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local9); + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + instance.getMachine().call(142, callArgs_7); + instance.global(0).setValue(((long) (local3 + 64))); + return 0; + } + + public static long[] call_870(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_870(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_871(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_871(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_871(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_872(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_872(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_872(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_873(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 136); + arg1 = (memory.readInt((int) local2 < 0 ? local2 : local2 + 52) + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(((memory.readInt((int) (local2 + 144) < 0 ? (local2 + 144) : (local2 + 144) + 0) - local3) >> 2), arg1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (local2 + 140) < 0 ? (local2 + 140) : (local2 + 140) + 0); + arg1 = (arg1 << 2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local4 = (local4 + ((arg0 - local3) & -4)); + arg1 = local4; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg0) != 0) { + break label_3; + } + arg1 = local4; + label_4: while (true) { + arg1 = (arg1 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 144, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 140, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 136, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_873(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_873(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_874(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local4 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local6 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 88); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local5); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 51, (byte) (0)); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 40, (byte) (0)); + memory.writeLong((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0, (long) 0L); + memory.writeI32((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (int) local4); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) local6); + memory.writeLong((int) (local7 + 56) < 0 ? (local7 + 56) : (local7 + 56) + 0, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeLong((int) (local7 + 64) < 0 ? (local7 + 64) : (local7 + 64) + 0, (long) memory.readLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + memory.writeI32((int) (local7 + 71) < 0 ? (local7 + 71) : (local7 + 71) + 0, (int) memory.readInt((int) (arg3 + 15) < 0 ? (arg3 + 15) : (arg3 + 15) + 0)); + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) (local7 + 80) < 0 ? (local7 + 80) : (local7 + 80) + 0, (long) local8); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) 5); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 51572); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg3 = (arg0 + 389); + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 0, (byte) ((((int) memory.read((int) arg3 < 0 ? arg3 : arg3 + 0) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-23, (int) local8)))); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local7); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(149, callArgs_2); + return 0; + } + + public static long[] call_874(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_874(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_875(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_875(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_875(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_876(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_876(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_876(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_877(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 160); + arg1 = (memory.readInt((int) local2 < 0 ? local2 : local2 + 56) + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(((memory.readInt((int) (local2 + 168) < 0 ? (local2 + 168) : (local2 + 168) + 0) - local3) >> 2), arg1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (local2 + 164) < 0 ? (local2 + 164) : (local2 + 164) + 0); + arg1 = (arg1 << 2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local4 = (local4 + ((arg0 - local3) & -4)); + arg1 = local4; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg0) != 0) { + break label_3; + } + arg1 = local4; + label_4: while (true) { + arg1 = (arg1 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 168, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 164, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 160, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_877(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_877(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_878(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local4 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local6 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 88); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + memory.writeI32((int) (local7 + 71) < 0 ? (local7 + 71) : (local7 + 71) + 0, (int) memory.readInt((int) (arg2 + 15) < 0 ? (arg2 + 15) : (arg2 + 15) + 0)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) 7); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local5); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 51, (byte) (0)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 51332); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 40, (byte) (0)); + memory.writeLong((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0, (long) 0L); + memory.writeI32((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (int) local4); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) local6); + memory.writeLong((int) (local7 + 56) < 0 ? (local7 + 56) : (local7 + 56) + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (local7 + 64) < 0 ? (local7 + 64) : (local7 + 64) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) (local7 + 80) < 0 ? (local7 + 80) : (local7 + 80) + 0, (int) arg3); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (local7 + 73) < 0 ? (local7 + 73) : (local7 + 73) + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (arg0 + 390) < 0 ? (arg0 + 390) : (arg0 + 390) + 0, (byte) (1)); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local7); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(147, callArgs_2); + return 0; + } + + public static long[] call_878(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_878(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_879(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_879(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_879(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_880(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_880(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_880(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_881(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 88); + arg1 = (memory.readInt((int) local2 < 0 ? local2 : local2 + 60) + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(((memory.readInt((int) (local2 + 96) < 0 ? (local2 + 96) : (local2 + 96) + 0) - local3) >> 2), arg1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (local2 + 92) < 0 ? (local2 + 92) : (local2 + 92) + 0); + arg1 = (arg1 << 2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local4 = (local4 + ((arg0 - local3) & -4)); + arg1 = local4; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg0) != 0) { + break label_3; + } + arg1 = local4; + label_4: while (true) { + arg1 = (arg1 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 92, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 88, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_881(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_881(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_882(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local4 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local6 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 72); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) 1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local5); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 47, (byte) (0)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 50996); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 36, (byte) (0)); + memory.writeLong((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0, (long) 0L); + memory.writeI32((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (int) local4); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) local6); + memory.writeI32((int) (local7 + 68) < 0 ? (local7 + 68) : (local7 + 68) + 0, (int) 0); + memory.writeLong((int) (local7 + 60) < 0 ? (local7 + 60) : (local7 + 60) + 0, (long) 0L); + memory.writeByte((int) (local7 + 56) < 0 ? (local7 + 56) : (local7 + 56) + 0, (byte) (arg3)); + local8 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) (local7 + 48) < 0 ? (local7 + 48) : (local7 + 48) + 0, (long) local8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local7); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + instance.getMachine().call(144, callArgs_2); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg0 = (int) local8; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 388, (byte) ((((int) memory.read((int) local7 < 0 ? local7 : local7 + 388) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-5, arg0)))); + local7 = (local7 + 389); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 0, (byte) ((((int) memory.read((int) local7 < 0 ? local7 : local7 + 0) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-23, arg0)))); + return 0; + } + + public static long[] call_882(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_882(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_883(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) (memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 88) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 88) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 88) + (arg1 << 2)) + 0) + 24)); + callArgs_0[1] = ((long) 1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(884, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_883(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_883(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_884(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local5 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local5), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 16384) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 14160); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + return 1; + } + label_2: { + local7 = memory.readInt((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local7) != 0) { + break label_2; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0, (int) (local4 + 12)); + return 0; + } + label_3: { + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local7 - local5), 12); + local8 = (local7 << 1); + local9 = (local6 + 1); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local9) != 0 ? local8 : local9) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 357913942) != 0) { + break label_3; + } + local7 = (local7 * 12); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local7); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local8 = ((int) callResult_1[0]); + local6 = (local8 + (local6 * 12)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg3); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg1); + arg3 = (local8 + local7); + arg2 = (local6 + 12); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local4) != 0) { + break label_4; + } + label_5: while (true) { + local6 = (local6 + -12); + local4 = (local4 + -12); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (int) memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) local6); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) arg3); + memory.writeI32((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0, (int) arg2); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_6; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_2); + } + return 0; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_884(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_884(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_885(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0), memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0)) != 0) { + break label_1; + } + return 0; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 11636); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + return 1; + } + + public static long[] call_885(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_885(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_886(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_886(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_886(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_887(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_887(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_887(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_888(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_888(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_888(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_889(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 112); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(((memory.readInt((int) (local2 + 120) < 0 ? (local2 + 120) : (local2 + 120) + 0) - local3) >> 2), arg1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (local2 + 116) < 0 ? (local2 + 116) : (local2 + 116) + 0); + arg1 = (arg1 << 2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local4 = (local4 + ((arg0 - local3) & -4)); + arg1 = local4; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg0) != 0) { + break label_3; + } + arg1 = local4; + label_4: while (true) { + arg1 = (arg1 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 120, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 116, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 112, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_889(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_889(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_890(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + long local12 = 0L; + local5 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 88); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local11 = ((int) callResult_1[0]); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 32, (int) 3); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 12, (int) local9); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 4, (long) 0L); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 36, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) 50448); + memory.writeLong((int) (local11 + 24) < 0 ? (local11 + 24) : (local11 + 24) + 0, (long) 0L); + memory.writeI32((int) (local11 + 20) < 0 ? (local11 + 20) : (local11 + 20) + 0, (int) local7); + memory.writeI32((int) (local11 + 16) < 0 ? (local11 + 16) : (local11 + 16) + 0, (int) local10); + memory.writeI32((int) (local11 + 44) < 0 ? (local11 + 44) : (local11 + 44) + 0, (int) 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local11 + 52)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + local7 = ((int) callResult_2[0]); + local12 = memory.readLong((int) arg4 < 0 ? arg4 : arg4 + 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (int) (local12 >>> 32L)); + callArgs_3[1] = ((long) (int) local12); + callArgs_3[0] = ((long) (local11 + 36)); + long[] callResult_3 = instance.getMachine().call(1649, callArgs_3); + arg4 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 12, (long) 0L); + local6 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local5); + callArgs_5[1] = ((long) arg3); + callArgs_5[0] = ((long) (local5 + 24)); + long[] callResult_5 = instance.getMachine().call(155, callArgs_5); + arg4 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) arg4); + callArgs_6[0] = ((long) local7); + long[] callResult_6 = instance.getMachine().call(158, callArgs_6); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + memory.writeI32((int) (local11 + 48) < 0 ? (local11 + 48) : (local11 + 48) + 0, (int) arg2); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local11); + callArgs_8[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + instance.getMachine().call(141, callArgs_8); + instance.global(0).setValue(((long) (local5 + 64))); + return 0; + } + + public static long[] call_890(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_890(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_891(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_891(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_891(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_892(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_892(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_892(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_893(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 52, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 44, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 40)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + arg1 = ((int) callResult_1[0]); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local7 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 72); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg0 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) (local2 + 40)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local3 = ((int) callResult_4[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 9); + memory.writeLong((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0, (long) 0L); + memory.writeI32((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (int) local4); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local5); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51452); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local3); + callArgs_5[0] = ((long) (arg0 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg0); + callArgs_7[0] = ((long) local6); + instance.getMachine().call(148, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + instance.global(0).setValue(((long) (local2 + 80))); + return 0; + } + + public static long[] call_893(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_893(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_894(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_894(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_894(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_895(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_895(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_895(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_896(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = 0; + label_1: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(((memory.readInt((int) (local3 + 80) < 0 ? (local3 + 80) : (local3 + 80) + 0) - memory.readInt((int) local3 < 0 ? local3 : local3 + 76)) >> 2), (memory.readInt((int) local3 < 0 ? local3 : local3 + 48) + arg1)) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 17050); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + local2 = 1; + } + return local2; + } + + public static long[] call_896(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_896(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_897(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + arg1 = memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) arg1); + local3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local5 = ((int) callResult_0[0]); + memory.writeLong((int) (arg1 + 172) < 0 ? (arg1 + 172) : (arg1 + 172) + 0, (long) 0L); + memory.writeI32((int) (arg1 + 168) < 0 ? (arg1 + 168) : (arg1 + 168) + 0, (int) local3); + memory.writeI32((int) (arg1 + 164) < 0 ? (arg1 + 164) : (arg1 + 164) + 0, (int) local5); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 160, (int) local4); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 148)); + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(884, callArgs_1); + return ((int) callResult_1[0]); + } + + public static long[] call_897(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_897(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_898(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_898(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_898(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_899(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + long local5 = 0L; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + local5 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) local5); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) local5); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (arg3 + 116)); + instance.getMachine().call(900, callArgs_0); + label_1: { + label_2: { + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) + 116)); + long[] callResult_1 = instance.getMachine().call(130, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(((int) callResult_1[0]), 50001) != 0) { + break label_2; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 15479); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + arg0 = 1; + break label_1; + } + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg3 = (int) local5; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 388, (byte) ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 388) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-5, arg3)))); + arg0 = (arg0 + 389); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-23, arg3)))); + arg0 = 0; + } + instance.global(0).setValue(((long) (local4 + 16))); + return arg0; + } + + public static long[] call_899(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_899(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_900(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_3; + } + label_4: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, local4) != 0) { + break label_4; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local3 + 12)); + return; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local5), 12); + local7 = (local6 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 357913942) != 0) { + break label_2; + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local5), 12); + local8 = (local4 << 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local7) != 0 ? local8 : local7) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 357913942) != 0) { + break label_1; + } + local7 = (local4 * 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local8 = ((int) callResult_0[0]); + local4 = (local8 + (local6 * 12)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg2); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + arg2 = (local8 + local7); + arg1 = (local4 + 12); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local3) != 0) { + break label_5; + } + label_6: while (true) { + local4 = (local4 + -12); + local3 = (local3 + -12); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_1); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_900(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_900(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_901(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_901(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_901(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_902(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) arg1); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0)) != 0) { + break label_3; + } + local3 = (arg0 + 40); + local4 = (arg0 + 52); + arg1 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(arg1, 146); + local6 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + (local5 << 2)) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + (local5 << 2)) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + (local5 << 2)) + 0); + local5 = (arg1 - (local5 * 146)); + arg1 = (local6 + (local5 * 28)); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0) { + break label_3; + } + label_4: { + label_5: { + label_6: { + local8 = (arg1 + 24); + if (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) != 0) { + break label_6; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) ((local6 + (local5 * 28)) + 4)); + long[] callResult_0 = instance.getMachine().call(840, callArgs_0); + arg1 = (arg0 + 56); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + -1)); + arg1 = (arg0 + 52); + _snap_0 = arg1; + arg1 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 1); + memory.writeI32((int) _snap_0 < 0 ? _snap_0 : _snap_0 + 0, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg1, 291) != 0) { + break label_3; + } + arg1 = 0; + local5 = -146; + break label_5; + } + arg1 = (local6 + (local5 * 28)); + local3 = (arg1 + 8); + local4 = (arg1 + 20); + arg1 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local5 = (memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + ((arg1 >>> 8) & 16777212)) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + ((arg1 >>> 8) & 16777212)) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + ((arg1 >>> 8) & 16777212)) + 0) + ((arg1 & 1023) << 2)); + arg1 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local6 = (memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0) + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, (memory.readInt((int) (local7 + 168) < 0 ? (local7 + 168) : (local7 + 168) + 0) + memory.readInt((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0))) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 20, (int) local6); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 12, (long) 0L); + arg1 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local7 = (memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + ((local5 >>> 8) & 16777212)) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + ((local5 >>> 8) & 16777212)) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + ((local5 >>> 8) & 16777212)) + 0) + ((local5 & 1023) << 2)); + local6 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 0); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_7; + } + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + } + local6 = (local5 + 1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local6); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + -1)); + local5 = -1024; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 2048) != 0) { + break label_4; + } + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 0)); + instance.getMachine().call(1777, callArgs_2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + local5)); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + local5 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local3 = ((int) callResult_3[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0, (int) local5); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local5 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local5), 12); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local4) != 0) { + break label_8; + } + arg0 = memory.readInt((int) (((local3 * 12) + local5) + -8) < 0 ? (((local3 * 12) + local5) + -8) : (((local3 * 12) + local5) + -8) + 0); + local5 = arg0; + label_9: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_9; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + local5 = (local4 + 4); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local2); + callArgs_4[1] = ((long) 17615); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_4); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + arg0 = 1; + break label_1; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local2 + 8)); + callArgs_6[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_6); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 388, (byte) ((((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 388) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-5, memory.readInt((int) local2 < 0 ? local2 : local2 + 24))))); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) (local2 + 8)); + callArgs_7[0] = ((long) (local2 + 16)); + instance.getMachine().call(192, callArgs_7); + arg0 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 390); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(254, ((int) memory.read((int) local2 < 0 ? local2 : local2 + 64) & 0xFF))))); + } + arg0 = 0; + } + instance.global(0).setValue(((long) (local2 + 80))); + return arg0; + } + + public static long[] call_902(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_902(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_903(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_903(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_903(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_904(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_904(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_904(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_905(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_905(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_905(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_906(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_906(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_906(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_907(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_907(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_907(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_908(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_908(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_908(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_909(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_909(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_909(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_910(int arg0, long arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_910(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int result = Wat2WasmMachine.func_910(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_911(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_911(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_911(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_912(int arg0, long arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_912(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int result = Wat2WasmMachine.func_912(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_913(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_913(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_913(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_914(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_914(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_914(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_915(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_915(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_915(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_916(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local10); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local9); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 96); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local5 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local10 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local5 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local9 = ((int) callResult_4[0]); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 0L); + local11 = (arg2 + 20); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + local12 = (arg2 + 12); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 56692); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local9); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 56524); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local9 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + arg1 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local9); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local6); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local9 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local9), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local9) + -8) < 0 ? (((local6 * 12) + local9) + -8) : (((local6 * 12) + local9) + -8) + 0); + local9 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local9 = (arg1 + 4); + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local5); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local7); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local5 + 160))); + return arg2; + } + + public static long[] call_916(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_916(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_917(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local10); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local9); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 96); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local5 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local10 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local5 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local9 = ((int) callResult_4[0]); + local11 = (arg2 + 20); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + local12 = (arg2 + 12); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 12884901888L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 56876); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local9); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 56708); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local9 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + arg1 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local9); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local6); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local9 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local9), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local9) + -8) < 0 ? (((local6 * 12) + local9) + -8) : (((local6 * 12) + local9) + -8) + 0); + local9 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local9 = (arg1 + 4); + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local5); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local7); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local5 + 160))); + return arg2; + } + + public static long[] call_917(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_917(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_918(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local10); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local9); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 96); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local5 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local10 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local5 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local9 = ((int) callResult_4[0]); + local11 = (arg2 + 20); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + local12 = (arg2 + 12); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 4294967296L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 57060); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local9); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 56892); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local9 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + arg1 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local9); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local6); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local9 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local9), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local9) + -8) < 0 ? (((local6 * 12) + local9) + -8) : (((local6 * 12) + local9) + -8) + 0); + local9 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local9 = (arg1 + 4); + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local5); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local7); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local5 + 160))); + return arg2; + } + + public static long[] call_918(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_918(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_919(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local10); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local9); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 96); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local5 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local10 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local5 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local9 = ((int) callResult_4[0]); + local11 = (arg2 + 20); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + local12 = (arg2 + 12); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 8589934592L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 57244); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local9); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 57076); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local9 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + arg1 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local9); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local6); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local9 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local9), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local9) + -8) < 0 ? (((local6 * 12) + local9) + -8) : (((local6 * 12) + local9) + -8) + 0); + local9 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local9 = (arg1 + 4); + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local5); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local7); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local5 + 160))); + return arg2; + } + + public static long[] call_919(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_919(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_920(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local10); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local9); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 96); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local5 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local10 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local5 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local9 = ((int) callResult_4[0]); + local11 = (arg2 + 20); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + local12 = (arg2 + 12); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 25769803776L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 56508); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local9); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 56340); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local9 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + arg1 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local9); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local6); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local9 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local9), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local9) + -8) < 0 ? (((local6 * 12) + local9) + -8) : (((local6 * 12) + local9) + -8) + 0); + local9 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local9 = (arg1 + 4); + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local5); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local7); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local5 + 160))); + return arg2; + } + + public static long[] call_920(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_920(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_921(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 40); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 49260); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + arg1 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + arg1 = (local4 + 4); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local3 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_921(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_921(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_922(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local10); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local9); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 96); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local5 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local10 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local5 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local9 = ((int) callResult_4[0]); + local11 = (arg2 + 20); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + local12 = (arg2 + 12); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 17179869184L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 56324); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local9); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 56156); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local9 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + arg1 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local9); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local6); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local9 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local9), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local9) + -8) < 0 ? (((local6 * 12) + local9) + -8) : (((local6 * 12) + local9) + -8) + 0); + local9 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local9 = (arg1 + 4); + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local5); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local7); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local5 + 160))); + return arg2; + } + + public static long[] call_922(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_922(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_923(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 40); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 53884); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + arg1 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + arg1 = (local4 + 4); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local3 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_923(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_923(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_924(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 184); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 36, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 57720); + local4 = (local3 + 20); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + local5 = (local3 + 12); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeLong((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (long) 34359738368L); + memory.writeLong((int) (local3 + 41) < 0 ? (local3 + 41) : (local3 + 41) + 0, (long) 0L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + 52)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local3 + 120) < 0 ? (local3 + 120) : (local3 + 120) + 0, (long) 0L); + memory.writeLong((int) (local3 + 112) < 0 ? (local3 + 112) : (local3 + 112) + 0, (long) 0L); + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) 0L); + memory.writeLong((int) (local3 + 96) < 0 ? (local3 + 96) : (local3 + 96) + 0, (long) 0L); + memory.writeLong((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0, (long) 0L); + memory.writeLong((int) (local3 + 132) < 0 ? (local3 + 132) : (local3 + 132) + 0, (long) 0L); + memory.writeI32((int) (local3 + 128) < 0 ? (local3 + 128) : (local3 + 128) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 140) < 0 ? (local3 + 140) : (local3 + 140) + 0, (long) 0L); + local6 = (local3 + 152); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeI32((int) (local3 + 148) < 0 ? (local3 + 148) : (local3 + 148) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 160) < 0 ? (local3 + 160) : (local3 + 160) + 0, (long) 0L); + memory.writeLong((int) (local3 + 168) < 0 ? (local3 + 168) : (local3 + 168) + 0, (long) 0L); + memory.writeLong((int) (local3 + 176) < 0 ? (local3 + 176) : (local3 + 176) + 0, (long) 0L); + local7 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local7); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) local7); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local2 + 16)); + callArgs_2[1] = ((long) (local3 + 48)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(925, callArgs_2); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local8 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local8); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local9 = ((int) callResult_3[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local9); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local8); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg1 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + local4 = arg1; + label_3: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local5); + local4 = (local5 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) + 1)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) 0); + callArgs_4[2] = ((long) local6); + callArgs_4[1] = ((long) 2); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(884, callArgs_4); + local3 = ((int) callResult_4[0]); + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 32))); + return local3; + } + + public static long[] call_924(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_924(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_925(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0) { + break label_2; + } + arg2 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) 0L); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local6 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local5); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) (local3 + 24)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + arg2 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg2); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(862, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg2); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + break label_1; + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (0)); + memory.writeI32((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 40)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) local3); + instance.getMachine().call(367, callArgs_4); + label_3: { + arg0 = memory.readInt((int) (arg1 + 52) < 0 ? (arg1 + 52) : (arg1 + 52) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + memory.writeI32((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0, (int) arg0); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 52, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeLong((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 4)); + } + instance.global(0).setValue(((long) (local3 + 64))); + return; + } + + public static long[] call_925(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_925(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_926(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 52000); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 38654705664L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_926(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_926(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_927(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 52112); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 42949672960L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_927(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_927(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_928(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local4)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 84); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local5 = ((int) callResult_0[0]); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 4, (long) 0L); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 36, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 52224); + memory.writeLong((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0, (long) 0L); + memory.writeLong((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0, (long) 0L); + memory.writeLong((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (long) 47244640256L); + memory.writeI32((int) (local5 + 44) < 0 ? (local5 + 44) : (local5 + 44) + 0, (int) 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local5 + 48)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + local6 = ((int) callResult_1[0]); + local7 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 28, (long) 0L); + local8 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local8); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local9 = ((int) callResult_2[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) local7); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) local8); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local4 + 16)); + callArgs_3[1] = ((long) arg3); + callArgs_3[0] = ((long) (local4 + 40)); + long[] callResult_3 = instance.getMachine().call(155, callArgs_3); + arg3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg3); + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(158, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg3); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + local10 = (local5 + 36); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) (local5 + 40) < 0 ? (local5 + 40) : (local5 + 40) + 0); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 36); + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - local7), 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, arg1) != 0) { + break label_3; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (arg1 - arg3)); + callArgs_6[0] = ((long) local10); + instance.getMachine().call(929, callArgs_6); + break label_2; + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg3, arg1) != 0) { + break label_4; + } + label_5: { + local7 = (local7 + (arg1 * 36)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local6) != 0) { + break label_5; + } + arg3 = (local6 + -36); + label_6: while (true) { + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg3); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local6 = ((int) callResult_7[0]); + arg3 = (arg3 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) local7); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + } + arg3 = 0; + local11 = (arg0 + 32); + label_7: while (true) { + local6 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local7 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 28, (long) 0L); + local8 = memory.readInt((int) local11 < 0 ? local11 : local11 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local8); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local9 = ((int) callResult_8[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) local7); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) local9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) local8); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local4 + 16)); + callArgs_9[1] = ((long) local6); + callArgs_9[0] = ((long) (local4 + 40)); + long[] callResult_9 = instance.getMachine().call(155, callArgs_9); + local6 = ((int) callResult_9[0]); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) local6); + callArgs_10[0] = ((long) (memory.readInt((int) local10 < 0 ? local10 : local10 + 0) + arg3)); + long[] callResult_10 = instance.getMachine().call(158, callArgs_10); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local6); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + arg3 = (arg3 + 36); + arg2 = (arg2 + 4); + arg1 = (arg1 + -1); + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + arg2 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + arg3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) arg3); + long[] callResult_12 = instance.getMachine().call(1897, callArgs_12); + local6 = ((int) callResult_12[0]); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) 0L); + memory.writeI32((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0, (int) arg2); + memory.writeI32((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg3); + arg3 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg2 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg3 - arg2), 12); + label_8: { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg3) != 0) { + break label_9; + } + arg2 = memory.readInt((int) (((local6 * 12) + arg2) + -8) < 0 ? (((local6 * 12) + arg2) + -8) : (((local6 * 12) + arg2) + -8) + 0); + arg3 = arg2; + label_10: { + local6 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_10; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local6); + arg3 = (local6 + 4); + } + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) local5); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) local5); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 8) + 1)); + arg2 = 0; + break label_8; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local6); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) local4); + callArgs_13[1] = ((long) 17615); + callArgs_13[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_13); + int ciTableIdx_14 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_14 = instance.table(0).requiredRef(ciTableIdx_14); + com.dylibso.chicory.runtime.Instance ciRefInstance_14 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_14), instance); + if (!ciRefInstance_14.type(ciRefInstance_14.functionType(ciFuncId_14)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local5); + ciRefInstance_14.getMachine().call(ciFuncId_14, callArgs_14); + arg2 = 1; + } + instance.global(0).setValue(((long) (local4 + 80))); + return arg2; + } + + public static long[] call_928(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_928(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_929(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 36), arg1) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + local2 = (local3 + (arg1 * 36)); + label_3: while (true) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + arg1 = ((int) callResult_0[0]); + local3 = (local3 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, (arg1 + 36)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local3 = local2; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + return; + } + label_4: { + label_5: { + label_6: { + label_7: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 36); + local3 = (local5 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 119304648) != 0) { + break label_7; + } + label_8: { + label_9: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local4), 36); + local4 = (local2 << 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, local3) != 0 ? local4 : local3) : 119304647); + if (local4 != 0) { + break label_9; + } + local6 = 0; + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 119304648) != 0) { + break label_6; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local4 * 36)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local6 = ((int) callResult_1[0]); + } + local7 = (local6 + (local5 * 36)); + local2 = (local7 + (arg1 * 36)); + local3 = local7; + label_10: while (true) { + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local3); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + arg1 = ((int) callResult_2[0]); + local3 = (local3 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, (arg1 + 36)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + local8 = (local6 + (local4 * 36)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_5; + } + arg1 = (((local5 * 36) + local6) + -36); + label_11: while (true) { + local3 = (local3 + -36); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local3); + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local6 = ((int) callResult_3[0]); + arg1 = (arg1 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local8); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg1) != 0) { + break label_4; + } + arg1 = (arg1 + -36); + label_12: while (true) { + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local2 = ((int) callResult_4[0]); + arg1 = (arg1 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break label_4; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_13; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_7); + } + return; + } + + public static long[] call_929(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_929(arg0, arg1, memory, instance); + return null; + } + + public static int func_930(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 52392); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 51539607552L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_930(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_930(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_931(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 176); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 52504); + local5 = (local4 + 20); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + local6 = (local4 + 12); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeLong((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (long) 55834574848L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local4 + 40)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local4 + 108) < 0 ? (local4 + 108) : (local4 + 108) + 0, (long) 0L); + memory.writeLong((int) (local4 + 100) < 0 ? (local4 + 100) : (local4 + 100) + 0, (long) 0L); + memory.writeLong((int) (local4 + 92) < 0 ? (local4 + 92) : (local4 + 92) + 0, (long) 0L); + memory.writeLong((int) (local4 + 84) < 0 ? (local4 + 84) : (local4 + 84) + 0, (long) 0L); + memory.writeLong((int) (local4 + 76) < 0 ? (local4 + 76) : (local4 + 76) + 0, (long) 0L); + memory.writeLong((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0, (long) 0L); + memory.writeI32((int) (local4 + 116) < 0 ? (local4 + 116) : (local4 + 116) + 0, (int) 1065353216); + memory.writeLong((int) (local4 + 128) < 0 ? (local4 + 128) : (local4 + 128) + 0, (long) 0L); + memory.writeI32((int) (local4 + 136) < 0 ? (local4 + 136) : (local4 + 136) + 0, (int) 1065353216); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local4 + 140)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + local7 = ((int) callResult_2[0]); + local8 = (arg0 + 4); + local9 = memory.readInt((int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 8) < 0 ? (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 8) : (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 44, (long) 0L); + local10 = (arg0 + 32); + local11 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local11); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local12 = ((int) callResult_3[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) local9); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local12); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local11); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local3 + 32)); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) (local3 + 72)); + long[] callResult_4 = instance.getMachine().call(155, callArgs_4); + arg1 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) arg1); + callArgs_5[1] = ((long) (local4 + 36)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(862, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + arg1 = memory.readInt((int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 8) < 0 ? (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 8) : (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 20, (long) 0L); + local9 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local9); + long[] callResult_7 = instance.getMachine().call(1897, callArgs_7); + local11 = ((int) callResult_7[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local11); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local9); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (local3 + 8)); + callArgs_8[1] = ((long) arg2); + callArgs_8[0] = ((long) (local3 + 32)); + long[] callResult_8 = instance.getMachine().call(155, callArgs_8); + arg1 = ((int) callResult_8[0]); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) arg1); + callArgs_9[0] = ((long) local7); + long[] callResult_9 = instance.getMachine().call(158, callArgs_9); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg1); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local8 = memory.readInt((int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 8) < 0 ? (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 8) : (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 8) + 0); + local10 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local10); + long[] callResult_11 = instance.getMachine().call(1897, callArgs_11); + arg1 = ((int) callResult_11[0]); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local8); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local10); + local10 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local8 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local10 - local8), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local10) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((arg1 * 12) + local8) + -8) < 0 ? (((arg1 * 12) + local8) + -8) : (((arg1 * 12) + local8) + -8) + 0); + local8 = arg0; + label_3: { + local10 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_3; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local10); + local8 = (local10 + 4); + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local4 = 0; + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) local3); + callArgs_12[1] = ((long) 17615); + callArgs_12[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_12); + int ciTableIdx_13 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_13 = instance.table(0).requiredRef(ciTableIdx_13); + com.dylibso.chicory.runtime.Instance ciRefInstance_13 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_13), instance); + if (!ciRefInstance_13.type(ciRefInstance_13.functionType(ciFuncId_13)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local4); + ciRefInstance_13.getMachine().call(ciFuncId_13, callArgs_13); + local4 = 1; + } + instance.global(0).setValue(((long) (local3 + 112))); + return local4; + } + + public static long[] call_931(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_931(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_932(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 72); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 4, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 48864); + local3 = (local2 + 20); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + local4 = (local2 + 12); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeLong((int) (local2 + 28) < 0 ? (local2 + 28) : (local2 + 28) + 0, (long) 60129542144L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local2 + 36)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + local5 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local6 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local7 = ((int) callResult_2[0]); + memory.writeLong((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local5); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) local7); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local6); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + local3) + -8) < 0 ? (((local5 * 12) + local3) + -8) : (((local5 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local4); + local3 = (local4 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local2 = 0; + break label_1; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local1); + callArgs_3[1] = ((long) 17615); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_3); + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local2); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + local2 = 1; + } + instance.global(0).setValue(((long) (local1 + 16))); + return local2; + } + + public static long[] call_932(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_932(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_933(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + local3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 20, (long) 0L); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local5 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local4); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 8)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 32)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) (local2 + 88) < 0 ? (local2 + 88) : (local2 + 88) + 0, (int) 0); + memory.writeLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0, (long) 0L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) (local2 + 92)); + long[] callResult_2 = instance.getMachine().call(159, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeI32((int) (local2 + 136) < 0 ? (local2 + 136) : (local2 + 136) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 128, (long) 0L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 72)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(934, callArgs_3); + local5 = ((int) callResult_3[0]); + label_1: { + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 128); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + label_2: while (true) { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + arg0 = arg1; + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 136, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 128, (long) 0L); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + instance.global(0).setValue(((long) (local2 + 144))); + return local5; + } + + public static long[] call_933(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_933(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_934(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 17615); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + arg0 = 1; + break label_1; + } + label_3: { + local5 = (local5 + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(6, memory.readInt((int) (local4 + (local5 * 12)) < 0 ? (local4 + (local5 * 12)) : (local4 + (local5 * 12)) + 0)) != 0) { + break label_3; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 0); + callArgs_1[1] = ((long) 13905); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_1); + arg0 = 1; + break label_1; + } + local3 = memory.readInt((int) (local4 + (local5 * 12)) < 0 ? (local4 + (local5 * 12)) : (local4 + (local5 * 12)) + 8); + label_4: { + if (memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0)) != 0) { + break label_4; + } + local6 = memory.readInt((int) (local3 + 192) < 0 ? (local3 + 192) : (local3 + 192) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, memory.readInt((int) local3 < 0 ? local3 : local3 + 188)) != 0) { + break label_4; + } + local6 = (local6 + -68); + if (memory.readInt((int) (local6 + 40) < 0 ? (local6 + 40) : (local6 + 40) + 0) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) (local6 + 44) < 0 ? (local6 + 44) : (local6 + 44) + 0)) != 0) { + break label_4; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 13838); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + arg0 = 1; + break label_1; + } + label_5: { + label_6: { + label_7: { + switch(memory.readInt((int) local3 < 0 ? local3 : local3 + 36)) { + case 0: + { + break label_6; + } + case 1: + { + break label_5; + } + default: + { + break label_7; + } + } + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) 15558); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_3); + arg0 = 1; + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) 1); + } + label_8: { + label_9: { + arg0 = memory.readInt((int) (local3 + 192) < 0 ? (local3 + 192) : (local3 + 192) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, memory.readInt((int) (local3 + 196) < 0 ? (local3 + 196) : (local3 + 196) + 0)) != 0) { + break label_9; + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (arg1 + 20)); + callArgs_4[0] = ((long) (arg0 + 20)); + long[] callResult_4 = instance.getMachine().call(157, callArgs_4); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 56, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 56)); + memory.writeI32((int) (arg0 + 64) < 0 ? (arg0 + 64) : (arg0 + 64) + 0, (int) memory.readInt((int) (arg1 + 64) < 0 ? (arg1 + 64) : (arg1 + 64) + 0)); + arg0 = (arg0 + 68); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 192, (int) arg0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 56, (int) 0); + memory.writeLong((int) (arg1 + 60) < 0 ? (arg1 + 60) : (arg1 + 60) + 0, (long) 0L); + break label_8; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) (local3 + 188)); + instance.getMachine().call(1303, callArgs_5); + arg0 = memory.readInt((int) local3 < 0 ? local3 : local3 + 192); + } + memory.writeI32((int) (local4 + (local5 * 12)) < 0 ? (local4 + (local5 * 12)) : (local4 + (local5 * 12)) + 4, (int) (arg0 + -12)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local2 + 16))); + return arg0; + } + + public static long[] call_934(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_934(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_935(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local1)); + local2 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local4 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 20, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 16, (int) local2); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) local3); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local1 + 28)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) (local1 + 72) < 0 ? (local1 + 72) : (local1 + 72) + 0, (int) 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 64, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local1 + 8)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(934, callArgs_2); + local4 = ((int) callResult_2[0]); + label_1: { + arg0 = memory.readInt((int) local1 < 0 ? local1 : local1 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + arg0 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 72, (int) 0); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 64, (long) 0L); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + instance.global(0).setValue(((long) (local1 + 80))); + return local4; + } + + public static long[] call_935(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_935(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_936(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 40); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 16); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 54000); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + arg1 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + arg1 = (local4 + 4); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local3 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_936(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_936(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_937(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 40); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 18); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 54116); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + arg1 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + arg1 = (local4 + 4); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local3 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_937(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_937(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_938(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 17615); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + local4 = 1; + break label_1; + } + label_3: { + local3 = (local5 + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(6, memory.readInt((int) (local4 + (local3 * 12)) < 0 ? (local4 + (local3 * 12)) : (local4 + (local3 * 12)) + 0)) != 0) { + break label_3; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 0); + callArgs_1[1] = ((long) 13932); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_1); + local4 = 1; + break label_1; + } + label_4: { + label_5: { + label_6: { + local4 = memory.readInt((int) (local4 + (local3 * 12)) < 0 ? (local4 + (local3 * 12)) : (local4 + (local3 * 12)) + 8); + switch(memory.readInt((int) local4 < 0 ? local4 : local4 + 36)) { + case 0: + { + break label_5; + } + case 1: + { + break label_6; + } + case 2: + { + break label_4; + } + default: + { + break label_6; + } + } + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 14251); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + local4 = 1; + break label_1; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) 2); + } + local3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local5); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local6 = ((int) callResult_3[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local5); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local2 + 16)); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) (local2 + 40)); + long[] callResult_4 = instance.getMachine().call(155, callArgs_4); + _snap_0 = local4; + local4 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) (_snap_0 + 200)); + long[] callResult_5 = instance.getMachine().call(158, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local4); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + label_7: { + local4 = (arg0 + 24); + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20), local3) != 0) { + break label_7; + } + local4 = 0; + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) 14035); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_7); + break label_1; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) (local3 + -12)); + local4 = 0; + } + instance.global(0).setValue(((long) (local2 + 80))); + return local4; + } + + public static long[] call_938(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_938(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_939(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 36); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 4, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) 19); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 51932); + local3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (long) 0L); + memory.writeI32((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0, (int) local3); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + local3) + -8) < 0 ? (((local5 * 12) + local3) + -8) : (((local5 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local4); + local3 = (local4 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local2 = 0; + break label_1; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local1); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + local2 = 1; + } + instance.global(0).setValue(((long) (local1 + 16))); + return local2; + } + + public static long[] call_939(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_939(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_940(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local1 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local1)); + local2 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + break label_2; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 0); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local1); + callArgs_0[1] = ((long) 17615); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + local2 = 1; + break label_1; + } + local2 = 1; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 1) != 0) { + break label_3; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 20, (int) local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 16, (int) 1); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local1 + 16)); + callArgs_1[1] = ((long) 17615); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_1); + break label_1; + } + label_4: { + local5 = memory.readInt((int) (((local4 * 12) + local3) + -20) < 0 ? (((local4 * 12) + local3) + -20) : (((local4 * 12) + local3) + -20) + 0); + if (memory.readInt((int) local5 < 0 ? local5 : local5 + 8) != 0) { + break label_4; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) 5863); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + break label_1; + } + label_5: { + local4 = (local4 + -1); + local6 = (local3 + (local4 * 12)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(4, memory.readInt((int) local6 < 0 ? local6 : local6 + 0)) != 0) { + break label_5; + } + local2 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local7 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local7); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local8 = ((int) callResult_3[0]); + arg0 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + memory.writeLong((int) (arg0 + 176) < 0 ? (arg0 + 176) : (arg0 + 176) + 0, (long) 0L); + memory.writeI32((int) (arg0 + 172) < 0 ? (arg0 + 172) : (arg0 + 172) + 0, (int) local2); + memory.writeI32((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0, (int) local8); + memory.writeI32((int) (arg0 + 164) < 0 ? (arg0 + 164) : (arg0 + 164) + 0, (int) local7); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 5); + memory.writeI32((int) (local3 + (local4 * 12)) < 0 ? (local3 + (local4 * 12)) : (local3 + (local4 * 12)) + 4, (int) (arg0 + 184)); + local2 = 0; + break label_1; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) 14728); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_4); + } + instance.global(0).setValue(((long) (local1 + 32))); + return local2; + } + + public static long[] call_940(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_940(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_941(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + local2 = (arg0 + 24); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local4), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2) != 0) { + break label_2; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_3; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 0); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local1); + callArgs_0[1] = ((long) 17615); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + arg0 = 1; + break label_1; + } + label_4: { + local3 = ((local5 * 12) + local4); + local4 = memory.readInt((int) (local3 + -20) < 0 ? (local3 + -20) : (local3 + -20) + 0); + if (memory.readInt((int) local4 < 0 ? local4 : local4 + 8) != 0) { + break label_4; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 0); + callArgs_1[1] = ((long) 5863); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_1); + arg0 = 1; + break label_1; + } + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + switch((memory.readInt((int) (local3 + -12) < 0 ? (local3 + -12) : (local3 + -12) + 0) + -2)) { + case 0: + { + break label_11; + } + case 1: + { + break label_10; + } + case 2: + { + break label_9; + } + case 3: + { + break label_8; + } + case 4: + { + break label_7; + } + case 5: + { + break label_6; + } + default: + { + break label_2; + } + } + } + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local3); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local5 = ((int) callResult_2[0]); + memory.writeI32((int) (local4 + 172) < 0 ? (local4 + 172) : (local4 + 172) + 0, (int) memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0)); + memory.writeI32((int) (local4 + 168) < 0 ? (local4 + 168) : (local4 + 168) + 0, (int) local5); + memory.writeI32((int) (local4 + 164) < 0 ? (local4 + 164) : (local4 + 164) + 0, (int) local3); + local4 = (local4 + 176); + break label_5; + } + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local5 = ((int) callResult_3[0]); + memory.writeI32((int) (local4 + 172) < 0 ? (local4 + 172) : (local4 + 172) + 0, (int) memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0)); + memory.writeI32((int) (local4 + 168) < 0 ? (local4 + 168) : (local4 + 168) + 0, (int) local5); + memory.writeI32((int) (local4 + 164) < 0 ? (local4 + 164) : (local4 + 164) + 0, (int) local3); + local4 = (local4 + 176); + break label_5; + } + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local5 = ((int) callResult_4[0]); + memory.writeI32((int) (local4 + 172) < 0 ? (local4 + 172) : (local4 + 172) + 0, (int) memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0)); + memory.writeI32((int) (local4 + 168) < 0 ? (local4 + 168) : (local4 + 168) + 0, (int) local5); + memory.writeI32((int) (local4 + 164) < 0 ? (local4 + 164) : (local4 + 164) + 0, (int) local3); + local4 = (local4 + 176); + break label_5; + } + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local3); + long[] callResult_5 = instance.getMachine().call(1897, callArgs_5); + local5 = ((int) callResult_5[0]); + memory.writeI32((int) (local4 + 204) < 0 ? (local4 + 204) : (local4 + 204) + 0, (int) memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0)); + memory.writeI32((int) (local4 + 200) < 0 ? (local4 + 200) : (local4 + 200) + 0, (int) local5); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 196, (int) local3); + local4 = (local4 + 208); + break label_5; + } + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + long[] callResult_6 = instance.getMachine().call(1897, callArgs_6); + local5 = ((int) callResult_6[0]); + memory.writeI32((int) (local4 + 176) < 0 ? (local4 + 176) : (local4 + 176) + 0, (int) memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0)); + memory.writeI32((int) (local4 + 172) < 0 ? (local4 + 172) : (local4 + 172) + 0, (int) local5); + memory.writeI32((int) (local4 + 168) < 0 ? (local4 + 168) : (local4 + 168) + 0, (int) local3); + local4 = (local4 + 180); + break label_5; + } + local3 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local3); + long[] callResult_7 = instance.getMachine().call(1897, callArgs_7); + local5 = ((int) callResult_7[0]); + memory.writeI32((int) (local4 + 172) < 0 ? (local4 + 172) : (local4 + 172) + 0, (int) memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0)); + memory.writeI32((int) (local4 + 168) < 0 ? (local4 + 168) : (local4 + 168) + 0, (int) local5); + memory.writeI32((int) (local4 + 164) < 0 ? (local4 + 164) : (local4 + 164) + 0, (int) local3); + local4 = (local4 + 176); + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + } + label_12: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20), local4) != 0) { + break label_12; + } + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 0); + callArgs_8[1] = ((long) 14035); + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_8); + arg0 = 1; + break label_1; + } + memory.writeI32((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0, (int) (local4 + -12)); + arg0 = 0; + } + instance.global(0).setValue(((long) (local1 + 16))); + return arg0; + } + + public static long[] call_941(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_941(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_942(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local6 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 104); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 36, (int) local5); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) (local7 + 88) < 0 ? (local7 + 88) : (local7 + 88) + 0, (int) 0); + memory.writeI32((int) (local7 + 72) < 0 ? (local7 + 72) : (local7 + 72) + 0, (int) arg1); + memory.writeLong((int) (local7 + 56) < 0 ? (local7 + 56) : (local7 + 56) + 0, (long) -3L); + memory.writeLong((int) (local7 + 48) < 0 ? (local7 + 48) : (local7 + 48) + 0, (long) 0L); + memory.writeI32((int) (local7 + 44) < 0 ? (local7 + 44) : (local7 + 44) + 0, (int) local4); + memory.writeI32((int) (local7 + 40) < 0 ? (local7 + 40) : (local7 + 40) + 0, (int) local6); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) 17); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 48964); + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local3 = ((int) callResult_2[0]); + memory.writeLong((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0, (long) 0L); + memory.writeI32((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (int) arg1); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) local3); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local5); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local5 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local5), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local3 * 12) + local5) + -8) < 0 ? (((local3 * 12) + local5) + -8) : (((local3 * 12) + local5) + -8) + 0); + local5 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 8, (int) arg1); + local5 = (arg1 + 4); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local7 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 17615); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_4); + local7 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local7; + } + + public static long[] call_942(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_942(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_943(int arg0, long arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local6 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 104); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 36, (int) local5); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) (local7 + 88) < 0 ? (local7 + 88) : (local7 + 88) + 0, (int) 0); + memory.writeLong((int) (local7 + 72) < 0 ? (local7 + 72) : (local7 + 72) + 0, (long) arg1); + memory.writeLong((int) (local7 + 56) < 0 ? (local7 + 56) : (local7 + 56) + 0, (long) -4L); + memory.writeLong((int) (local7 + 48) < 0 ? (local7 + 48) : (local7 + 48) + 0, (long) 0L); + memory.writeI32((int) (local7 + 44) < 0 ? (local7 + 44) : (local7 + 44) + 0, (int) local4); + memory.writeI32((int) (local7 + 40) < 0 ? (local7 + 40) : (local7 + 40) + 0, (int) local6); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) 17); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 48964); + local3 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0, (long) 0L); + memory.writeI32((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (int) local3); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) local4); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local5); + local3 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local5 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local5), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local3) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local4 * 12) + local5) + -8) < 0 ? (((local4 * 12) + local5) + -8) : (((local4 * 12) + local5) + -8) + 0); + local5 = arg0; + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 8, (int) local3); + local5 = (local3 + 4); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local7 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 17615); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_4); + local7 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local7; + } + + public static long[] call_943(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int result = Wat2WasmMachine.func_943(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_944(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + local3 = ((local2 + 8) + 8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local4 = ((local2 + 8) + 16); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + local5 = (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local7 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local8 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 104); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) local7); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeLong((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0, (long) -5L); + memory.writeLong((int) (arg1 + 48) < 0 ? (arg1 + 48) : (arg1 + 48) + 0, (long) 0L); + memory.writeI32((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0, (int) local6); + memory.writeI32((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0, (int) local8); + memory.writeLong((int) (arg1 + 64) < 0 ? (arg1 + 64) : (arg1 + 64) + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + memory.writeLong((int) (arg1 + 72) < 0 ? (arg1 + 72) : (arg1 + 72) + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeLong((int) (arg1 + 80) < 0 ? (arg1 + 80) : (arg1 + 80) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (arg1 + 88) < 0 ? (arg1 + 88) : (arg1 + 88) + 0, (int) 0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 32, (int) 17); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 48964); + local3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 12, (int) local7); + local3 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local7 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local7), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local3) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local4 * 12) + local7) + -8) < 0 ? (((local4 * 12) + local7) + -8) : (((local4 * 12) + local7) + -8) + 0); + local7 = arg0; + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local3); + local7 = (local3 + 4); + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 17615); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_4); + arg1 = 1; + } + instance.global(0).setValue(((long) (local2 + 32))); + return arg1; + } + + public static long[] call_944(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_944(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_945(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 53168); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 85899345920L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_945(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_945(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_946(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 53280); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 90194313216L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_946(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_946(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_947(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local6 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 104); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 36, (int) local5); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) (local7 + 88) < 0 ? (local7 + 88) : (local7 + 88) + 0, (int) 0); + memory.writeI32((int) (local7 + 72) < 0 ? (local7 + 72) : (local7 + 72) + 0, (int) arg1); + memory.writeLong((int) (local7 + 56) < 0 ? (local7 + 56) : (local7 + 56) + 0, (long) -1L); + memory.writeLong((int) (local7 + 48) < 0 ? (local7 + 48) : (local7 + 48) + 0, (long) 0L); + memory.writeI32((int) (local7 + 44) < 0 ? (local7 + 44) : (local7 + 44) + 0, (int) local4); + memory.writeI32((int) (local7 + 40) < 0 ? (local7 + 40) : (local7 + 40) + 0, (int) local6); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) 17); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 48964); + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local3 = ((int) callResult_2[0]); + memory.writeLong((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0, (long) 0L); + memory.writeI32((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (int) arg1); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) local3); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local5); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local5 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local5), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local3 * 12) + local5) + -8) < 0 ? (((local3 * 12) + local5) + -8) : (((local3 * 12) + local5) + -8) + 0); + local5 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 8, (int) arg1); + local5 = (arg1 + 4); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local7 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 17615); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_4); + local7 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local7; + } + + public static long[] call_947(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_947(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_948(int arg0, long arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local6 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 104); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 36, (int) local5); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) (local7 + 88) < 0 ? (local7 + 88) : (local7 + 88) + 0, (int) 0); + memory.writeLong((int) (local7 + 72) < 0 ? (local7 + 72) : (local7 + 72) + 0, (long) arg1); + memory.writeLong((int) (local7 + 56) < 0 ? (local7 + 56) : (local7 + 56) + 0, (long) -2L); + memory.writeLong((int) (local7 + 48) < 0 ? (local7 + 48) : (local7 + 48) + 0, (long) 0L); + memory.writeI32((int) (local7 + 44) < 0 ? (local7 + 44) : (local7 + 44) + 0, (int) local4); + memory.writeI32((int) (local7 + 40) < 0 ? (local7 + 40) : (local7 + 40) + 0, (int) local6); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) 17); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 48964); + local3 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0, (long) 0L); + memory.writeI32((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (int) local3); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) local4); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local5); + local3 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local5 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local5), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local3) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local4 * 12) + local5) + -8) < 0 ? (((local4 * 12) + local5) + -8) : (((local4 * 12) + local5) + -8) + 0); + local5 = arg0; + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 8, (int) local3); + local5 = (local3 + 4); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local7 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) 17615); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_4); + local7 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local7; + } + + public static long[] call_948(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int result = Wat2WasmMachine.func_948(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_949(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 216); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 36, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 57960); + local4 = (local3 + 20); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + local5 = (local3 + 12); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeLong((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (long) 94489280512L); + memory.writeLong((int) (local3 + 41) < 0 ? (local3 + 41) : (local3 + 41) + 0, (long) 0L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + 52)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local3 + 120) < 0 ? (local3 + 120) : (local3 + 120) + 0, (long) 0L); + memory.writeLong((int) (local3 + 112) < 0 ? (local3 + 112) : (local3 + 112) + 0, (long) 0L); + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) 0L); + memory.writeLong((int) (local3 + 96) < 0 ? (local3 + 96) : (local3 + 96) + 0, (long) 0L); + memory.writeLong((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0, (long) 0L); + memory.writeLong((int) (local3 + 132) < 0 ? (local3 + 132) : (local3 + 132) + 0, (long) 0L); + memory.writeI32((int) (local3 + 128) < 0 ? (local3 + 128) : (local3 + 128) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 140) < 0 ? (local3 + 140) : (local3 + 140) + 0, (long) 0L); + local6 = (local3 + 152); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeI32((int) (local3 + 148) < 0 ? (local3 + 148) : (local3 + 148) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 160) < 0 ? (local3 + 160) : (local3 + 160) + 0, (long) 0L); + memory.writeLong((int) (local3 + 168) < 0 ? (local3 + 168) : (local3 + 168) + 0, (long) 0L); + memory.writeLong((int) (local3 + 176) < 0 ? (local3 + 176) : (local3 + 176) + 0, (long) 0L); + memory.writeLong((int) (local3 + 184) < 0 ? (local3 + 184) : (local3 + 184) + 0, (long) 0L); + memory.writeLong((int) (local3 + 192) < 0 ? (local3 + 192) : (local3 + 192) + 0, (long) 0L); + memory.writeLong((int) (local3 + 200) < 0 ? (local3 + 200) : (local3 + 200) + 0, (long) 0L); + memory.writeLong((int) (local3 + 208) < 0 ? (local3 + 208) : (local3 + 208) + 0, (long) 0L); + local7 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) local7); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local7); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local2 + 16)); + callArgs_2[1] = ((long) (local3 + 48)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(925, callArgs_2); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local8 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local8); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local9 = ((int) callResult_3[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local9); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local8); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg1 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + local4 = arg1; + label_3: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local5); + local4 = (local5 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) + 1)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) 0); + callArgs_4[2] = ((long) local6); + callArgs_4[1] = ((long) 4); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(884, callArgs_4); + local3 = ((int) callResult_4[0]); + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 32))); + return local3; + } + + public static long[] call_949(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_949(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_950(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local10); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local9); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 96); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local5 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local10 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local5 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local9 = ((int) callResult_4[0]); + local11 = (arg2 + 20); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + local12 = (arg2 + 12); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 98784247808L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 53564); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local9); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 53392); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local9 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + arg1 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local9); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local6); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local9 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local9), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local9) + -8) < 0 ? (((local6 * 12) + local9) + -8) : (((local6 * 12) + local9) + -8) + 0); + local9 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local9 = (arg1 + 4); + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local5); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local7); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local5 + 160))); + return arg2; + } + + public static long[] call_950(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_950(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_951(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 52832); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 103079215104L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_951(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_951(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_952(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 52944); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 107374182400L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_952(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_952(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_953(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 53056); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 111669149696L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_953(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_953(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_954(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 184); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 36, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 57840); + local4 = (local3 + 20); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + local5 = (local3 + 12); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeLong((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (long) 115964116992L); + memory.writeLong((int) (local3 + 41) < 0 ? (local3 + 41) : (local3 + 41) + 0, (long) 0L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + 52)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local3 + 120) < 0 ? (local3 + 120) : (local3 + 120) + 0, (long) 0L); + memory.writeLong((int) (local3 + 112) < 0 ? (local3 + 112) : (local3 + 112) + 0, (long) 0L); + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) 0L); + memory.writeLong((int) (local3 + 96) < 0 ? (local3 + 96) : (local3 + 96) + 0, (long) 0L); + memory.writeLong((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0, (long) 0L); + memory.writeLong((int) (local3 + 132) < 0 ? (local3 + 132) : (local3 + 132) + 0, (long) 0L); + memory.writeI32((int) (local3 + 128) < 0 ? (local3 + 128) : (local3 + 128) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 140) < 0 ? (local3 + 140) : (local3 + 140) + 0, (long) 0L); + local6 = (local3 + 152); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeI32((int) (local3 + 148) < 0 ? (local3 + 148) : (local3 + 148) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 160) < 0 ? (local3 + 160) : (local3 + 160) + 0, (long) 0L); + memory.writeLong((int) (local3 + 168) < 0 ? (local3 + 168) : (local3 + 168) + 0, (long) 0L); + memory.writeLong((int) (local3 + 176) < 0 ? (local3 + 176) : (local3 + 176) + 0, (long) 0L); + local7 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local7); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) local7); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local2 + 16)); + callArgs_2[1] = ((long) (local3 + 48)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(925, callArgs_2); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local8 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local8); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local9 = ((int) callResult_3[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local9); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local8); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg1 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + local4 = arg1; + label_3: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local5); + local4 = (local5 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) + 1)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) 0); + callArgs_4[2] = ((long) local6); + callArgs_4[1] = ((long) 3); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(884, callArgs_4); + local3 = ((int) callResult_4[0]); + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 32))); + return local3; + } + + public static long[] call_954(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_954(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_955(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local3 = (((int) instance.global(0).getValue()) - 224); + instance.global(0).setValue(((long) local3)); + local4 = (arg0 + 4); + local5 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 92, (long) 0L); + local6 = (arg0 + 32); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local8 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 84, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 80, (int) local7); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 80)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local3 + 104)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local5 = ((int) callResult_1[0]); + arg1 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 28, (long) 0L); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local8 = ((int) callResult_2[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) local7); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) (local3 + 40)); + long[] callResult_3 = instance.getMachine().call(155, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 108); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg1 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local5); + callArgs_5[0] = ((long) (local3 + 184)); + long[] callResult_5 = instance.getMachine().call(157, callArgs_5); + local7 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) arg2); + callArgs_6[0] = ((long) (local3 + 144)); + long[] callResult_6 = instance.getMachine().call(157, callArgs_6); + local8 = ((int) callResult_6[0]); + local9 = (arg1 + 20); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) 0L); + local10 = (arg1 + 12); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 0, (long) 0L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 120259084288L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 54232); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local7); + callArgs_7[0] = ((long) (arg1 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local8); + callArgs_8[0] = ((long) (arg1 + 72)); + long[] callResult_8 = instance.getMachine().call(159, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local8); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local7); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local4 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + local6 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local6); + long[] callResult_11 = instance.getMachine().call(1897, callArgs_11); + local7 = ((int) callResult_11[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) local4); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local7); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) local6); + local6 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - local4), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local7 * 12) + local4) + -8) < 0 ? (((local7 * 12) + local4) + -8) : (((local7 * 12) + local4) + -8) + 0); + local4 = arg0; + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local6); + local4 = (local6 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) local3); + callArgs_12[1] = ((long) 17615); + callArgs_12[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_12); + int ciTableIdx_13 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_13 = instance.table(0).requiredRef(ciTableIdx_13); + com.dylibso.chicory.runtime.Instance ciRefInstance_13 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_13), instance); + if (!ciRefInstance_13.type(ciRefInstance_13.functionType(ciFuncId_13)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) arg1); + ciRefInstance_13.getMachine().call(ciFuncId_13, callArgs_13); + arg1 = 1; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) arg2); + long[] callResult_14 = instance.getMachine().call(162, callArgs_14); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local5); + long[] callResult_15 = instance.getMachine().call(162, callArgs_15); + instance.global(0).setValue(((long) (local3 + 224))); + return arg1; + } + + public static long[] call_955(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_955(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_956(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 54472); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 124554051584L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_956(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_956(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_957(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 20, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 8)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 32)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (local2 + 72)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local6 = ((int) callResult_3[0]); + local7 = (arg1 + 20); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + local8 = (arg1 + 12); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 128849018880L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 54356); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local6); + callArgs_4[0] = ((long) (arg1 + 36)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + local6 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + long[] callResult_6 = instance.getMachine().call(1897, callArgs_6); + local5 = ((int) callResult_6[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local6); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local5); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local3); + local3 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local6 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local6), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local3) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + local6) + -8) < 0 ? (((local5 * 12) + local6) + -8) : (((local5 * 12) + local6) + -8) + 0); + local6 = arg0; + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local3); + local6 = (local3 + 4); + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local2); + callArgs_7[1] = ((long) 17615); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_7); + int ciTableIdx_8 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + arg1 = 1; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + instance.global(0).setValue(((long) (local2 + 112))); + return arg1; + } + + public static long[] call_957(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_957(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_958(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 20, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 8)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 32)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (local2 + 72)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local6 = ((int) callResult_3[0]); + local7 = (arg1 + 20); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + local8 = (arg1 + 12); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 133143986176L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 54888); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local6); + callArgs_4[0] = ((long) (arg1 + 36)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + local6 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + long[] callResult_6 = instance.getMachine().call(1897, callArgs_6); + local5 = ((int) callResult_6[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local6); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local5); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local3); + local3 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local6 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local6), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local3) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + local6) + -8) < 0 ? (((local5 * 12) + local6) + -8) : (((local5 * 12) + local6) + -8) + 0); + local6 = arg0; + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local3); + local6 = (local3 + 4); + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local2); + callArgs_7[1] = ((long) 17615); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_7); + int ciTableIdx_8 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + arg1 = 1; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + instance.global(0).setValue(((long) (local2 + 112))); + return arg1; + } + + public static long[] call_958(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_958(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_959(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local3 = (((int) instance.global(0).getValue()) - 224); + instance.global(0).setValue(((long) local3)); + local4 = (arg0 + 4); + local5 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 92, (long) 0L); + local6 = (arg0 + 32); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local8 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 84, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 80, (int) local7); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 80)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local3 + 104)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local5 = ((int) callResult_1[0]); + arg1 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 28, (long) 0L); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local8 = ((int) callResult_2[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) local7); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) (local3 + 40)); + long[] callResult_3 = instance.getMachine().call(155, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 108); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg1 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) (local3 + 144)); + long[] callResult_5 = instance.getMachine().call(157, callArgs_5); + local8 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local8); + callArgs_6[0] = ((long) (local3 + 184)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local7 = ((int) callResult_6[0]); + local9 = (arg1 + 20); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) 0L); + local10 = (arg1 + 12); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 0, (long) 0L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 137438953472L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 54756); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local7); + callArgs_7[0] = ((long) (arg1 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local7); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 54584); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local5); + callArgs_9[0] = ((long) (arg1 + 72)); + long[] callResult_9 = instance.getMachine().call(159, callArgs_9); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local8); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local4 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + local6 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local6); + long[] callResult_11 = instance.getMachine().call(1897, callArgs_11); + local7 = ((int) callResult_11[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) local4); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local7); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) local6); + local6 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - local4), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local7 * 12) + local4) + -8) < 0 ? (((local7 * 12) + local4) + -8) : (((local7 * 12) + local4) + -8) + 0); + local4 = arg0; + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local6); + local4 = (local6 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) local3); + callArgs_12[1] = ((long) 17615); + callArgs_12[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_12); + int ciTableIdx_13 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_13 = instance.table(0).requiredRef(ciTableIdx_13); + com.dylibso.chicory.runtime.Instance ciRefInstance_13 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_13), instance); + if (!ciRefInstance_13.type(ciRefInstance_13.functionType(ciFuncId_13)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) arg1); + ciRefInstance_13.getMachine().call(ciFuncId_13, callArgs_13); + arg1 = 1; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) arg2); + long[] callResult_14 = instance.getMachine().call(162, callArgs_14); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local5); + long[] callResult_15 = instance.getMachine().call(162, callArgs_15); + instance.global(0).setValue(((long) (local3 + 224))); + return arg1; + } + + public static long[] call_959(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_959(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_960(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 20, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 8)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 32)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (local2 + 72)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local6 = ((int) callResult_3[0]); + local7 = (arg1 + 20); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + local8 = (arg1 + 12); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 141733920768L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 54772); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local6); + callArgs_4[0] = ((long) (arg1 + 36)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + local6 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + long[] callResult_6 = instance.getMachine().call(1897, callArgs_6); + local5 = ((int) callResult_6[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local6); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local5); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local3); + local3 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local6 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local6), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local3) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + local6) + -8) < 0 ? (((local5 * 12) + local6) + -8) : (((local5 * 12) + local6) + -8) + 0); + local6 = arg0; + label_3: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local3); + local6 = (local3 + 4); + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local2); + callArgs_7[1] = ((long) 17615); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_7); + int ciTableIdx_8 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + arg1 = 1; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + instance.global(0).setValue(((long) (local2 + 112))); + return arg1; + } + + public static long[] call_960(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_960(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_961(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + local4 = (arg0 + 4); + local5 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 92, (long) 0L); + local6 = (arg0 + 32); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local8 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 84, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 80, (int) local7); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 80)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local3 + 104)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local5 = ((int) callResult_1[0]); + arg1 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 28, (long) 0L); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local8 = ((int) callResult_2[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) local7); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) (local3 + 40)); + long[] callResult_3 = instance.getMachine().call(155, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 108); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg1 = ((int) callResult_4[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 49060); + local7 = (arg1 + 20); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + local8 = (arg1 + 12); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 214748364800L); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local5); + callArgs_5[0] = ((long) (arg1 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) arg2); + callArgs_6[0] = ((long) (arg1 + 72)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local4 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + local6 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local6); + long[] callResult_7 = instance.getMachine().call(1897, callArgs_7); + local9 = ((int) callResult_7[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local4); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local9); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local6); + local6 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - local4), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local7 * 12) + local4) + -8) < 0 ? (((local7 * 12) + local4) + -8) : (((local7 * 12) + local4) + -8) + 0); + local4 = arg0; + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local6); + local4 = (local6 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) local3); + callArgs_8[1] = ((long) 17615); + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_8); + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + arg1 = 1; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local5); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local3 + 144))); + return arg1; + } + + public static long[] call_961(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_961(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_962(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 55004); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 219043332096L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_962(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_962(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_963(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local3)); + local4 = (arg0 + 4); + local5 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 92, (long) 0L); + local6 = (arg0 + 32); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local8 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 88, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 84, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 80, (int) local7); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 + 80)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local3 + 104)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local5 = ((int) callResult_1[0]); + arg1 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 28, (long) 0L); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local8 = ((int) callResult_2[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) local7); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) (local3 + 40)); + long[] callResult_3 = instance.getMachine().call(155, callArgs_3); + arg2 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 108); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg1 = ((int) callResult_4[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 49160); + local7 = (arg1 + 20); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + local8 = (arg1 + 12); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 223338299392L); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local5); + callArgs_5[0] = ((long) (arg1 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) arg2); + callArgs_6[0] = ((long) (arg1 + 72)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local4 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + local6 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local6); + long[] callResult_7 = instance.getMachine().call(1897, callArgs_7); + local9 = ((int) callResult_7[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local4); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local9); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local6); + local6 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - local4), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local7 * 12) + local4) + -8) < 0 ? (((local7 * 12) + local4) + -8) : (((local7 * 12) + local4) + -8) + 0); + local4 = arg0; + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local6); + local4 = (local6 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) local3); + callArgs_8[1] = ((long) 17615); + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_8); + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + arg1 = 1; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local5); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local3 + 144))); + return arg1; + } + + public static long[] call_963(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_963(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_964(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 55116); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 227633266688L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_964(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_964(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_965(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 55228); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 240518168576L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_965(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_965(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_966(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 55340); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 231928233984L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_966(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_966(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_967(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 55452); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 236223201280L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_967(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_967(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_968(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 55564); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 244813135872L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_968(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_968(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_969(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local4 = (local3 + 396); + local5 = local4; + label_1: { + label_2: { + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + label_3: while (true) { + label_4: { + local5 = local6; + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local6, arg1) != 0) { + break label_4; + } + local4 = local5; + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, arg1) != 0) { + break label_1; + } + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local4 = (local5 + 4); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 20); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local6 = ((int) callResult_0[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local5); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local6); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) arg1); + label_5: { + local5 = memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 392) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 392) : memory.readInt((int) local3 < 0 ? local3 : local3 + 392) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_5; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 392, (int) local5); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local6); + callArgs_1[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 396)); + instance.getMachine().call(43, callArgs_1); + local5 = (local3 + 400); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 1)); + } + local6 = (arg0 + 4); + local5 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local4 = (arg0 + 32); + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local3); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local7 = ((int) callResult_2[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local3); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) (local2 + 40)); + long[] callResult_3 = instance.getMachine().call(155, callArgs_3); + arg1 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 72); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local5 = ((int) callResult_4[0]); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 4, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 49596); + local3 = (local5 + 20); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + local7 = (local5 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (long) 154618822656L); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) (local5 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local6 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local4); + long[] callResult_6 = instance.getMachine().call(1897, callArgs_6); + local8 = ((int) callResult_6[0]); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local6); + memory.writeI32((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local6 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local6), 12); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_7; + } + local6 = memory.readInt((int) (((local3 * 12) + local6) + -8) < 0 ? (((local3 * 12) + local6) + -8) : (((local3 * 12) + local6) + -8) + 0); + local4 = local6; + label_8: { + arg0 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_8; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg0); + local4 = (arg0 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local5); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local5); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 8) + 1)); + local5 = 0; + break label_6; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local2); + callArgs_7[1] = ((long) 17615); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_7); + int ciTableIdx_8 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local5); + ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + local5 = 1; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + instance.global(0).setValue(((long) (local2 + 80))); + return local5; + } + + public static long[] call_969(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_969(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_970(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) ((((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-23, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0))))); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 44); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 36, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 37); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 55676); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + arg1 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + arg1 = (local4 + 4); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local3 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_970(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_970(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_971(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 36); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 4, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) 35); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 55796); + local3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (long) 0L); + memory.writeI32((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0, (int) local3); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + local3) + -8) < 0 ? (((local5 * 12) + local3) + -8) : (((local5 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local4); + local3 = (local4 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local2 = 0; + break label_1; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local1); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + local2 = 1; + } + instance.global(0).setValue(((long) (local1 + 16))); + return local2; + } + + public static long[] call_971(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_971(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_972(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 36); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 4, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) 34); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 51864); + local3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (long) 0L); + memory.writeI32((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0, (int) local3); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + local3) + -8) < 0 ? (((local5 * 12) + local3) + -8) : (((local5 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local4); + local3 = (local4 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local2 = 0; + break label_1; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local1); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + local2 = 1; + } + instance.global(0).setValue(((long) (local1 + 16))); + return local2; + } + + public static long[] call_972(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_972(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_973(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 4); + local4 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local4 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 56044); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 163208757248L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local3 = memory.readInt((int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) < 0 ? (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) : (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local3); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local3) + -8) < 0 ? (((local6 * 12) + local3) + -8) : (((local6 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local3 = (local5 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_973(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_973(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_974(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 36); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 4, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) 39); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 52324); + local3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (long) 0L); + memory.writeI32((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0, (int) local3); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + local3) + -8) < 0 ? (((local5 * 12) + local3) + -8) : (((local5 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local4); + local3 = (local4 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local2 = 0; + break label_1; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local1); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + local2 = 1; + } + instance.global(0).setValue(((long) (local1 + 16))); + return local2; + } + + public static long[] call_974(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_974(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_975(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 180, (byte) (1)); + } + local4 = (arg0 + 4); + local3 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local5 = (arg0 + 32); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local3 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 52608); + local6 = (arg1 + 20); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local7 = (arg1 + 12); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 171798691840L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local3); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local4 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local8 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local4); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local8); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local4), 12); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local5) != 0) { + break label_3; + } + arg0 = memory.readInt((int) (((local6 * 12) + local4) + -8) < 0 ? (((local6 * 12) + local4) + -8) : (((local6 * 12) + local4) + -8) + 0); + local4 = arg0; + label_4: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_4; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local5); + local4 = (local5 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg1 = 0; + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + arg1 = 1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local3); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return arg1; + } + + public static long[] call_975(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_975(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_976(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + label_1: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 180, (byte) (1)); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 176); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 52720); + local5 = (local4 + 20); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeLong((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (long) 0L); + memory.writeLong((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (long) 176093659136L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local4 + 40)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local4 + 108) < 0 ? (local4 + 108) : (local4 + 108) + 0, (long) 0L); + memory.writeLong((int) (local4 + 100) < 0 ? (local4 + 100) : (local4 + 100) + 0, (long) 0L); + memory.writeLong((int) (local4 + 92) < 0 ? (local4 + 92) : (local4 + 92) + 0, (long) 0L); + memory.writeLong((int) (local4 + 84) < 0 ? (local4 + 84) : (local4 + 84) + 0, (long) 0L); + memory.writeLong((int) (local4 + 76) < 0 ? (local4 + 76) : (local4 + 76) + 0, (long) 0L); + memory.writeLong((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0, (long) 0L); + memory.writeI32((int) (local4 + 116) < 0 ? (local4 + 116) : (local4 + 116) + 0, (int) 1065353216); + memory.writeLong((int) (local4 + 128) < 0 ? (local4 + 128) : (local4 + 128) + 0, (long) 0L); + memory.writeI32((int) (local4 + 136) < 0 ? (local4 + 136) : (local4 + 136) + 0, (int) 1065353216); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local4 + 140)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + local6 = ((int) callResult_2[0]); + local7 = (arg0 + 4); + local8 = memory.readInt((int) (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) < 0 ? (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) : (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 44, (long) 0L); + local9 = (arg0 + 32); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local10); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local11 = ((int) callResult_3[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local11); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local10); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local3 + 32)); + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) (local3 + 72)); + long[] callResult_4 = instance.getMachine().call(155, callArgs_4); + local8 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local8); + callArgs_5[1] = ((long) (local4 + 36)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(862, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local8); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + local8 = memory.readInt((int) (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) < 0 ? (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) : (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 20, (long) 0L); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(1897, callArgs_7); + local11 = ((int) callResult_7[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local11); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local10); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (local3 + 8)); + callArgs_8[1] = ((long) arg2); + callArgs_8[0] = ((long) (local3 + 32)); + long[] callResult_8 = instance.getMachine().call(155, callArgs_8); + arg2 = ((int) callResult_8[0]); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) arg2); + callArgs_9[0] = ((long) local6); + long[] callResult_9 = instance.getMachine().call(158, callArgs_9); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local6 = memory.readInt((int) (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) < 0 ? (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) : (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 20, (long) 0L); + local8 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local8); + long[] callResult_11 = instance.getMachine().call(1897, callArgs_11); + local10 = ((int) callResult_11[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local10); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local8); + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) (local3 + 8)); + callArgs_12[1] = ((long) arg1); + callArgs_12[0] = ((long) (local3 + 32)); + long[] callResult_12 = instance.getMachine().call(155, callArgs_12); + local6 = ((int) callResult_12[0]); + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) local6); + callArgs_13[0] = ((long) arg2); + long[] callResult_13 = instance.getMachine().call(133, callArgs_13); + arg1 = ((int) callResult_13[0]); + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local6); + long[] callResult_14 = instance.getMachine().call(162, callArgs_14); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 104, (byte) (1)); + } + local7 = memory.readInt((int) (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) < 0 ? (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) : (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) + 0); + local9 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local9); + long[] callResult_15 = instance.getMachine().call(1897, callArgs_15); + arg1 = ((int) callResult_15[0]); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local7); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) arg1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local9); + local9 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local7 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local9 - local7), 12); + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local9) != 0) { + break label_4; + } + arg0 = memory.readInt((int) (((arg1 * 12) + local7) + -8) < 0 ? (((arg1 * 12) + local7) + -8) : (((arg1 * 12) + local7) + -8) + 0); + local7 = arg0; + label_5: { + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local9); + local7 = (local9 + 4); + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local4 = 0; + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) local3); + callArgs_16[1] = ((long) 17615); + callArgs_16[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_16); + int ciTableIdx_17 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_17 = instance.table(0).requiredRef(ciTableIdx_17); + com.dylibso.chicory.runtime.Instance ciRefInstance_17 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_17), instance); + if (!ciRefInstance_17.type(ciRefInstance_17.functionType(ciFuncId_17)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local4); + ciRefInstance_17.getMachine().call(ciFuncId_17, callArgs_17); + local4 = 1; + } + instance.global(0).setValue(((long) (local3 + 112))); + return local4; + } + + public static long[] call_976(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_976(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_977(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) 0L); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (arg2 + (arg1 << 3))); + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (local3 + 16)); + instance.getMachine().call(344, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + 16)); + long[] callResult_1 = instance.getMachine().call(978, callArgs_1); + arg2 = ((int) callResult_1[0]); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + local5 = ((int) callResult_2[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0, (int) arg1); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local5); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + arg1 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) local4); + arg1 = (local4 + 4); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg0 = 0; + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local3); + callArgs_3[1] = ((long) 17615); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_3); + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg2); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + arg0 = 1; + } + label_4: { + arg2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) arg2); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg2); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local3 + 32))); + return arg0; + } + + public static long[] call_977(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_977(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_978(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 48); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + local2 = 0; + local3 = 0; + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, local4) != 0) { + break label_2; + } + local3 = (local4 - arg0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local3, -1) != 0) { + break label_1; + } + local2 = 0; + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local3 = ((int) callResult_1[0]); + label_3: while (true) { + memory.writeLong((int) (local3 + local2) < 0 ? (local3 + local2) : (local3 + local2) + 0, (long) memory.readLong((int) (arg0 + local2) < 0 ? (arg0 + local2) : (arg0 + local2) + 0)); + local2 = (local2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, (arg0 + local2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = (local3 + local2); + } + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 36, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 48664); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) 0L); + memory.writeLong((int) (local1 + 12) < 0 ? (local1 + 12) : (local1 + 12) + 0, (long) 0L); + memory.writeLong((int) (local1 + 28) < 0 ? (local1 + 28) : (local1 + 28) + 0, (long) 180388626432L); + memory.writeI32((int) (local1 + 44) < 0 ? (local1 + 44) : (local1 + 44) + 0, (int) 0); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_4; + } + local2 = (local2 - local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local2, -1) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg0 = ((int) callResult_2[0]); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 36, (int) arg0); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 44, (int) (arg0 + ((local2 >> 3) << 3))); + local2 = (((local2 + -8) & -8) + 8); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local2); + callArgs_3[1] = ((long) local3); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1890, callArgs_3); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 40, (int) (((int) callResult_3[0]) + local2)); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_5; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_4); + } + return local1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_978(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_978(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_979(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local10); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local9); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 96); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local5 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local10 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local5 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local9 = ((int) callResult_4[0]); + local11 = (arg2 + 20); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + local12 = (arg2 + 12); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 210453397504L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 53752); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local9); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 53580); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local9 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + arg1 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local9); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local6); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local9 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local9), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local9) + -8) < 0 ? (((local6 * 12) + local9) + -8) : (((local6 * 12) + local9) + -8) + 0); + local9 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local9 = (arg1 + 4); + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local5); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local7); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local5 + 160))); + return arg2; + } + + public static long[] call_979(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_979(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_980(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = 1; + memory.writeByte((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) + 0, (byte) (1)); + local4 = (arg0 + 4); + local5 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 28, (long) 0L); + local6 = (arg0 + 32); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local8 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local7); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 16)); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local2 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local5 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 55864); + local7 = (arg1 + 20); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + local8 = (arg1 + 12); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + memory.writeLong((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (long) 253403070464L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (arg1 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + local4 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + local6 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local9 = ((int) callResult_4[0]); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local4); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) local9); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local6); + local6 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 - local4), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local7 * 12) + local4) + -8) < 0 ? (((local7 * 12) + local4) + -8) : (((local7 * 12) + local4) + -8) + 0); + local3 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + local3 = (local4 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local3 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local2); + callArgs_5[1] = ((long) 17615); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local5); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local2 + 80))); + return local3; + } + + public static long[] call_980(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_980(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_981(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + local2 = 1; + memory.writeByte((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) + 0, (byte) (1)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 36); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 60); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 55976); + local4 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local6 = ((int) callResult_1[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) local4); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local4 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local4), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local4) + -8) < 0 ? (((local6 * 12) + local4) + -8) : (((local6 * 12) + local4) + -8) + 0); + local2 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + local2 = (local4 + 4); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local2 = 0; + break label_1; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local6); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local1); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + } + instance.global(0).setValue(((long) (local1 + 16))); + return local2; + } + + public static long[] call_981(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_981(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_982(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 236); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 36, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 58052); + local4 = (local3 + 20); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + local5 = (local3 + 12); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeLong((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (long) 261993005056L); + memory.writeLong((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (long) 0L); + local6 = (local3 + 52); + memory.writeByte((int) local6 < 0 ? local6 : local6 + 0, (byte) (0)); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + 56)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local3 + 124) < 0 ? (local3 + 124) : (local3 + 124) + 0, (long) 0L); + memory.writeLong((int) (local3 + 116) < 0 ? (local3 + 116) : (local3 + 116) + 0, (long) 0L); + memory.writeLong((int) (local3 + 108) < 0 ? (local3 + 108) : (local3 + 108) + 0, (long) 0L); + memory.writeLong((int) (local3 + 100) < 0 ? (local3 + 100) : (local3 + 100) + 0, (long) 0L); + memory.writeLong((int) (local3 + 92) < 0 ? (local3 + 92) : (local3 + 92) + 0, (long) 0L); + memory.writeLong((int) (local3 + 136) < 0 ? (local3 + 136) : (local3 + 136) + 0, (long) 0L); + memory.writeI32((int) (local3 + 132) < 0 ? (local3 + 132) : (local3 + 132) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 144) < 0 ? (local3 + 144) : (local3 + 144) + 0, (long) 0L); + local7 = (local3 + 156); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeI32((int) (local3 + 152) < 0 ? (local3 + 152) : (local3 + 152) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 164) < 0 ? (local3 + 164) : (local3 + 164) + 0, (long) 0L); + memory.writeLong((int) (local3 + 172) < 0 ? (local3 + 172) : (local3 + 172) + 0, (long) 0L); + memory.writeLong((int) (local3 + 180) < 0 ? (local3 + 180) : (local3 + 180) + 0, (long) 0L); + memory.writeLong((int) (local3 + 188) < 0 ? (local3 + 188) : (local3 + 188) + 0, (long) 0L); + memory.writeI32((int) (local3 + 196) < 0 ? (local3 + 196) : (local3 + 196) + 0, (int) 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local3 + 200)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + local8 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local8); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) local8); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 16)); + callArgs_3[1] = ((long) local6); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(925, callArgs_3); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local6 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1897, callArgs_4); + local9 = ((int) callResult_4[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local9); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg1 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + local4 = arg1; + label_3: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local5); + local4 = (local5 + 4); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local3); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) + 1)); + memory.writeByte((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) + 0, (byte) (1)); + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) local3); + callArgs_5[2] = ((long) local7); + callArgs_5[1] = ((long) 6); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(884, callArgs_5); + local3 = ((int) callResult_5[0]); + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local2); + callArgs_6[1] = ((long) 17615); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_6); + int ciTableIdx_7 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local3); + ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 32))); + return local3; + } + + public static long[] call_982(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_982(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_983(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + local3 = (((int) instance.global(0).getValue()) - 192); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 196); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 36, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 58148); + local5 = (local4 + 20); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeLong((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (long) 0L); + memory.writeLong((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (long) 266287972352L); + memory.writeLong((int) (local4 + 41) < 0 ? (local4 + 41) : (local4 + 41) + 0, (long) 0L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local4 + 52)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0, (long) 0L); + memory.writeLong((int) (local4 + 112) < 0 ? (local4 + 112) : (local4 + 112) + 0, (long) 0L); + memory.writeLong((int) (local4 + 104) < 0 ? (local4 + 104) : (local4 + 104) + 0, (long) 0L); + memory.writeLong((int) (local4 + 96) < 0 ? (local4 + 96) : (local4 + 96) + 0, (long) 0L); + memory.writeLong((int) (local4 + 88) < 0 ? (local4 + 88) : (local4 + 88) + 0, (long) 0L); + memory.writeLong((int) (local4 + 132) < 0 ? (local4 + 132) : (local4 + 132) + 0, (long) 0L); + memory.writeI32((int) (local4 + 128) < 0 ? (local4 + 128) : (local4 + 128) + 0, (int) 1065353216); + memory.writeLong((int) (local4 + 140) < 0 ? (local4 + 140) : (local4 + 140) + 0, (long) 0L); + local6 = (local4 + 152); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeI32((int) (local4 + 148) < 0 ? (local4 + 148) : (local4 + 148) + 0, (int) 1065353216); + memory.writeLong((int) (local4 + 160) < 0 ? (local4 + 160) : (local4 + 160) + 0, (long) 0L); + memory.writeLong((int) (local4 + 168) < 0 ? (local4 + 168) : (local4 + 168) + 0, (long) 0L); + memory.writeLong((int) (local4 + 176) < 0 ? (local4 + 176) : (local4 + 176) + 0, (long) 0L); + local7 = (local4 + 184); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeI32((int) (local4 + 192) < 0 ? (local4 + 192) : (local4 + 192) + 0, (int) 0); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) - memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)), 12)); + callArgs_2[0] = ((long) local7); + instance.getMachine().call(984, callArgs_2); + local8 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 184, (long) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 16, (long) local8); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local3 + 16)); + callArgs_3[1] = ((long) (local4 + 48)); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(925, callArgs_3); + label_1: { + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local9 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_1; + } + local10 = ((local3 + 88) + 56); + local11 = ((local3 + 88) + 20); + local12 = ((local3 + 88) + 16); + local13 = (arg0 + 32); + label_2: while (true) { + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) 0); + local14 = ((local3 + 88) + 8); + memory.writeLong((int) local14 < 0 ? local14 : local14 + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 88, (long) 0L); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local11); + long[] callResult_4 = instance.getMachine().call(154, callArgs_4); + local15 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local10); + long[] callResult_5 = instance.getMachine().call(154, callArgs_5); + local16 = ((int) callResult_5[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 180, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + arg2 = memory.readInt((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0); + local17 = (arg0 + 4); + local18 = memory.readInt((int) (memory.readInt((int) local17 < 0 ? local17 : local17 + 0) + 8) < 0 ? (memory.readInt((int) local17 < 0 ? local17 : local17 + 0) + 8) : (memory.readInt((int) local17 < 0 ? local17 : local17 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 36, (long) 0L); + local19 = memory.readInt((int) local13 < 0 ? local13 : local13 + 0); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local19); + long[] callResult_6 = instance.getMachine().call(1897, callArgs_6); + local20 = ((int) callResult_6[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local18); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) local20); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local19); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local3 + 24)); + callArgs_7[1] = ((long) arg2); + callArgs_7[0] = ((long) (local3 + 48)); + long[] callResult_7 = instance.getMachine().call(155, callArgs_7); + arg2 = ((int) callResult_7[0]); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) arg2); + callArgs_8[0] = ((long) local15); + long[] callResult_8 = instance.getMachine().call(158, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg2); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + arg2 = memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0); + local17 = memory.readInt((int) (memory.readInt((int) local17 < 0 ? local17 : local17 + 0) + 8) < 0 ? (memory.readInt((int) local17 < 0 ? local17 : local17 + 0) + 8) : (memory.readInt((int) local17 < 0 ? local17 : local17 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 36, (long) 0L); + local18 = memory.readInt((int) local13 < 0 ? local13 : local13 + 0); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local18); + long[] callResult_10 = instance.getMachine().call(1897, callArgs_10); + local19 = ((int) callResult_10[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local17); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) local19); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local18); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local3 + 24)); + callArgs_11[1] = ((long) arg2); + callArgs_11[0] = ((long) (local3 + 48)); + long[] callResult_11 = instance.getMachine().call(155, callArgs_11); + arg2 = ((int) callResult_11[0]); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) arg2); + callArgs_12[0] = ((long) local16); + long[] callResult_12 = instance.getMachine().call(158, callArgs_12); + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) arg2); + long[] callResult_13 = instance.getMachine().call(162, callArgs_13); + label_3: { + label_4: { + arg2 = memory.readInt((int) local4 < 0 ? local4 : local4 + 188); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, memory.readInt((int) local4 < 0 ? local4 : local4 + 192)) != 0) { + break label_4; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 88)); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) memory.readInt((int) local12 < 0 ? local12 : local12 + 0)); + memory.writeLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (long) memory.readLong((int) local14 < 0 ? local14 : local14 + 0)); + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) local15); + callArgs_14[0] = ((long) (arg2 + 20)); + long[] callResult_14 = instance.getMachine().call(157, callArgs_14); + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) local16); + callArgs_15[0] = ((long) (arg2 + 56)); + long[] callResult_15 = instance.getMachine().call(157, callArgs_15); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 188, (int) (arg2 + 96)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 92, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 180)); + break label_3; + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) (local3 + 88)); + callArgs_16[0] = ((long) local7); + instance.getMachine().call(1306, callArgs_16); + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local16); + long[] callResult_17 = instance.getMachine().call(162, callArgs_17); + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) local15); + long[] callResult_18 = instance.getMachine().call(162, callArgs_18); + arg1 = (arg1 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + arg2 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) arg2); + long[] callResult_19 = instance.getMachine().call(1897, callArgs_19); + local15 = ((int) callResult_19[0]); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg1); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) local15); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg2); + arg2 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local15 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg2 - arg1), 12); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg2) != 0) { + break label_6; + } + arg1 = memory.readInt((int) (((local15 * 12) + arg1) + -8) < 0 ? (((local15 * 12) + arg1) + -8) : (((local15 * 12) + arg1) + -8) + 0); + arg2 = arg1; + label_7: { + local15 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_7; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local15); + arg2 = (local15 + 4); + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) + 1)); + memory.writeByte((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) + 0, (byte) (1)); + long[] callArgs_20 = new long[4]; + callArgs_20[3] = ((long) local4); + callArgs_20[2] = ((long) local6); + callArgs_20[1] = ((long) 7); + callArgs_20[0] = ((long) arg0); + long[] callResult_20 = instance.getMachine().call(884, callArgs_20); + arg1 = ((int) callResult_20[0]); + break label_5; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local15); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + long[] callArgs_21 = new long[3]; + callArgs_21[2] = ((long) local3); + callArgs_21[1] = ((long) 17615); + callArgs_21[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_21); + int ciTableIdx_22 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_22 = instance.table(0).requiredRef(ciTableIdx_22); + com.dylibso.chicory.runtime.Instance ciRefInstance_22 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_22), instance); + if (!ciRefInstance_22.type(ciRefInstance_22.functionType(ciFuncId_22)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) local4); + ciRefInstance_22.getMachine().call(ciFuncId_22, callArgs_22); + arg1 = 1; + } + instance.global(0).setValue(((long) (local3 + 192))); + return arg1; + } + + public static long[] call_983(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_983(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_984(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 96), arg1) != 0) { + break label_1; + } + label_2: { + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 44739243) != 0) { + break label_4; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + arg1 = (arg1 * 96); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local6 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local2), 96) * 96)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local3) != 0) { + break label_3; + } + arg1 = 0; + label_5: while (true) { + local4 = (local6 + arg1); + local7 = (local4 + -96); + local8 = (local3 + arg1); + local9 = (local8 + -96); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) local9 < 0 ? local9 : local9 + 0)); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) memory.readInt((int) (local9 + 16) < 0 ? (local9 + 16) : (local9 + 16) + 0)); + memory.writeLong((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0, (long) memory.readLong((int) (local9 + 8) < 0 ? (local9 + 8) : (local9 + 8) + 0)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local8 + -76)); + callArgs_1[0] = ((long) (local4 + -76)); + long[] callResult_1 = instance.getMachine().call(157, callArgs_1); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local8 + -40)); + callArgs_2[0] = ((long) (local4 + -40)); + long[] callResult_2 = instance.getMachine().call(157, callArgs_2); + memory.writeI32((int) (local4 + -4) < 0 ? (local4 + -4) : (local4 + -4) + 0, (int) memory.readInt((int) (local8 + -4) < 0 ? (local8 + -4) : (local8 + -4) + 0)); + arg1 = (arg1 + -96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, (local3 + arg1)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local6 + arg1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local4) != 0) { + break label_2; + } + label_6: while (true) { + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (local4 + -40)); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) (local4 + -76)); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local4 = (local4 + -96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break label_2; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_6); + } + return; + } + + public static long[] call_984(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_984(arg0, arg1, memory, instance); + return null; + } + + public static int func_985(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 40); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 63); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 53768); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + arg1 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + arg1 = (local4 + 4); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local3 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_985(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_985(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_986(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 40); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 58); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 57260); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) arg1); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + arg1) + -8) < 0 ? (((local5 * 12) + arg1) + -8) : (((local5 * 12) + arg1) + -8) + 0); + arg1 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + arg1 = (local4 + 4); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local3 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_986(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_986(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_987(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 36); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 4, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) 64); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 51796); + local3 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local4 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (long) 0L); + memory.writeI32((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0, (int) local3); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local4); + local4 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local3 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local4 - local3), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + local3) + -8) < 0 ? (((local5 * 12) + local3) + -8) : (((local5 * 12) + local3) + -8) + 0); + local3 = arg0; + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local4); + local3 = (local4 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local2 = 0; + break label_1; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local1); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + local2 = 1; + } + instance.global(0).setValue(((long) (local1 + 16))); + return local2; + } + + public static long[] call_987(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_987(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_988(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) 0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0), memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0)) != 0) { + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 11605); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_988(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_988(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_989(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_989(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_989(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_990(int arg0, int arg1, long arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 48); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) arg1); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 43); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 49364); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) arg2); + arg1 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local5 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local6 = ((int) callResult_1[0]); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) 0L); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) arg1); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) local6); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local5); + local5 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg1 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - arg1), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local5) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + arg1) + -8) < 0 ? (((local6 * 12) + arg1) + -8) : (((local6 * 12) + arg1) + -8) + 0); + arg1 = arg0; + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local5); + arg1 = (local5 + 4); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local4 = 0; + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + local4 = 1; + } + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_990(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + long arg2 = args[2]; + int result = Wat2WasmMachine.func_990(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_991(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 56); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) arg1); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (local4 + 48) < 0 ? (local4 + 48) : (local4 + 48) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 46); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 49468); + arg2 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + arg1 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg1); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) 0L); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) arg2); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) local5); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + arg2 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - arg2), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local5 * 12) + arg2) + -8) < 0 ? (((local5 * 12) + arg2) + -8) : (((local5 * 12) + arg2) + -8) + 0); + arg2 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + arg2 = (arg1 + 4); + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + local4 = 0; + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) 17615); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_3); + local4 = 1; + } + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_991(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_991(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_992(int arg0, int arg1, int arg2, long arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local6 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local6)); + local7 = (arg0 + 4); + local8 = memory.readInt((int) (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) < 0 ? (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) : (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) + 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 28, (long) 0L); + local9 = (arg0 + 32); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local10); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local11 = ((int) callResult_0[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) local8); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) local11); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) local10); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local6 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local6 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local8 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 104); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local8); + callArgs_3[0] = ((long) (local6 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local11 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local11); + callArgs_4[0] = ((long) (local6 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local10 = ((int) callResult_4[0]); + local12 = (arg2 + 20); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + local13 = (arg2 + 12); + memory.writeLong((int) local13 < 0 ? local13 : local13 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 188978561024L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 57532); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local10); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local10); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 96, (long) arg5); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 57376); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local11); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local10 = memory.readInt((int) (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) < 0 ? (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) : (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) + 0); + arg1 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local7 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) local10); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local7); + memory.writeI32((int) local13 < 0 ? local13 : local13 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local10 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local10), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local10, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local7 * 12) + local10) + -8) < 0 ? (((local7 * 12) + local10) + -8) : (((local7 * 12) + local10) + -8) + 0); + local10 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local10 = (arg1 + 4); + } + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local7); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local6); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local8); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local6 + 160))); + return arg2; + } + + public static long[] call_992(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_992(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_993(int arg0, int arg1, int arg2, long arg3, long arg4, long arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local6 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local6)); + local7 = (arg0 + 4); + local8 = memory.readInt((int) (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) < 0 ? (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) : (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) + 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 28, (long) 0L); + local9 = (arg0 + 32); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local10); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local11 = ((int) callResult_0[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) local8); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) local11); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) local10); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local6 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local6 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local8 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 104); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local8); + callArgs_3[0] = ((long) (local6 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local11 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local11); + callArgs_4[0] = ((long) (local6 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local10 = ((int) callResult_4[0]); + local12 = (arg2 + 20); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + local13 = (arg2 + 12); + memory.writeLong((int) local13 < 0 ? local13 : local13 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 193273528320L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 57704); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local10); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local10); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 96, (long) arg5); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 57548); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local11); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local10 = memory.readInt((int) (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) < 0 ? (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) : (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 8) + 0); + arg1 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local7 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) local10); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local7); + memory.writeI32((int) local13 < 0 ? local13 : local13 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local10 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local10), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local10, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local7 * 12) + local10) + -8) < 0 ? (((local7 * 12) + local10) + -8) : (((local7 * 12) + local10) + -8) + 0); + local10 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local10 = (arg1 + 4); + } + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local7); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local6); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local8); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local6 + 160))); + return arg2; + } + + public static long[] call_993(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + long arg5 = args[5]; + int result = Wat2WasmMachine.func_993(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_994(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local10); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local9); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 96); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local5 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local10 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local5 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local9 = ((int) callResult_4[0]); + local11 = (arg2 + 20); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + local12 = (arg2 + 12); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 201863462912L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 47168); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local9); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 46996); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local9 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + arg1 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local9); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local6); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local9 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local9), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local9) + -8) < 0 ? (((local6 * 12) + local9) + -8) : (((local6 * 12) + local9) + -8) + 0); + local9 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local9 = (arg1 + 4); + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local5); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local7); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local5 + 160))); + return arg2; + } + + public static long[] call_994(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_994(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_995(int arg0, int arg1, int arg2, long arg3, long arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local5)); + local6 = (arg0 + 4); + local7 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 28, (long) 0L); + local8 = (arg0 + 32); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local7); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local10); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local9); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local5 + 16)); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (local5 + 40)); + long[] callResult_1 = instance.getMachine().call(155, callArgs_1); + local7 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 96); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg2 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local7); + callArgs_3[0] = ((long) (local5 + 80)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + local10 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local10); + callArgs_4[0] = ((long) (local5 + 120)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + local9 = ((int) callResult_4[0]); + local11 = (arg2 + 20); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + local12 = (arg2 + 12); + memory.writeLong((int) local12 < 0 ? local12 : local12 + 0, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) 0L); + memory.writeLong((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (long) 206158430208L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 47356); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local9); + callArgs_5[0] = ((long) (arg2 + 36)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) arg4); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 80, (long) (1L << arg3)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 72, (int) arg1); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 47184); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local10); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + local9 = memory.readInt((int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) < 0 ? (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) : (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 8) + 0); + arg1 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(1897, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (long) 0L); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local9); + memory.writeI32((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (int) local6); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + arg1 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + local9 = memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((arg1 - local9), 12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, arg1) != 0) { + break label_2; + } + arg0 = memory.readInt((int) (((local6 * 12) + local9) + -8) < 0 ? (((local6 * 12) + local9) + -8) : (((local6 * 12) + local9) + -8) + 0); + local9 = arg0; + label_3: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) arg1); + local9 = (arg1 + 4); + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 1)); + arg2 = 0; + break label_1; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) local5); + callArgs_9[1] = ((long) 17615); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) < 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg2); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg2 = 1; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local7); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local5 + 160))); + return arg2; + } + + public static long[] call_995(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + long arg4 = args[4]; + int result = Wat2WasmMachine.func_995(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_996(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_996(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_996(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_997(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 148); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(((memory.readInt((int) (local2 + 156) < 0 ? (local2 + 156) : (local2 + 156) + 0) - local3) >> 2), arg1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (local2 + 152) < 0 ? (local2 + 152) : (local2 + 152) + 0); + arg1 = (arg1 << 2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local4 = (local4 + ((arg0 - local3) & -4)); + arg1 = local4; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg0) != 0) { + break label_3; + } + arg1 = local4; + label_4: while (true) { + arg1 = (arg1 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 156, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 152, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 148, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_997(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_997(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_998(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local4 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local4)); + local5 = (arg0 + 4); + local6 = memory.readInt((int) (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) < 0 ? (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) : (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) + 0); + local7 = (arg0 + 32); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local8); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local9 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 120); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local10 = ((int) callResult_1[0]); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 12, (int) local8); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 4, (long) 0L); + memory.writeByte((int) local10 < 0 ? local10 : local10 + 51, (byte) (0)); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 32, (long) 6L); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) 49940); + memory.writeLong((int) (local10 + 24) < 0 ? (local10 + 24) : (local10 + 24) + 0, (long) 0L); + memory.writeI32((int) (local10 + 20) < 0 ? (local10 + 20) : (local10 + 20) + 0, (int) local6); + memory.writeI32((int) (local10 + 16) < 0 ? (local10 + 16) : (local10 + 16) + 0, (int) local9); + memory.writeByte((int) (local10 + 40) < 0 ? (local10 + 40) : (local10 + 40) + 0, (byte) (0)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local10 + 52)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + local6 = ((int) callResult_2[0]); + memory.writeLong((int) (local10 + 112) < 0 ? (local10 + 112) : (local10 + 112) + 0, (long) 0L); + memory.writeLong((int) (local10 + 104) < 0 ? (local10 + 104) : (local10 + 104) + 0, (long) 0L); + memory.writeLong((int) (local10 + 96) < 0 ? (local10 + 96) : (local10 + 96) + 0, (long) 0L); + local5 = memory.readInt((int) (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) < 0 ? (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) : (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) 0L); + local7 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local7); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local8 = ((int) callResult_3[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local5); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local7); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local4); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local4 + 24)); + long[] callResult_4 = instance.getMachine().call(155, callArgs_4); + arg2 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(158, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg2); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 36, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(3, (arg3 & 3)) != 0 ? 2 : (arg3 & 1))); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local10); + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + instance.getMachine().call(139, callArgs_7); + instance.global(0).setValue(((long) (local4 + 64))); + return 0; + } + + public static long[] call_998(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_998(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_999(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) (memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) + 0) + 60)); + callArgs_0[1] = ((long) 1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(884, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_999(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_999(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1000(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0), memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0)) != 0) { + break label_1; + } + return 0; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 11636); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + return 1; + } + + public static long[] call_1000(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1000(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1001(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeLong((int) memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) + 0) : memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) + 0) + 52, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + return 0; + } + + public static long[] call_1001(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1001(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1002(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) (memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) + 0) + 72)); + instance.getMachine().call(1003, callArgs_0); + return 0; + } + + public static long[] call_1002(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1002(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1003(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 12), arg1) != 0) { + break label_1; + } + label_2: { + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 357913942) != 0) { + break label_4; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + arg1 = (arg1 * 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local6 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local3 - local2), 12) * 12)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local3) != 0) { + break label_3; + } + arg1 = (local3 + -12); + local3 = (local6 + -12); + label_5: while (true) { + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + memory.writeLong((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0, (long) 0L); + local3 = (local3 + -12); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, arg1); + arg1 = (arg1 + -12); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local3 + 12)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local5) != 0) { + break label_2; + } + label_6: while (true) { + label_7: { + local4 = (local5 + -12); + arg1 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_7; + } + label_8: while (true) { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg1); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + arg1 = local3; + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + memory.writeLong((int) (local5 + -8) < 0 ? (local5 + -8) : (local5 + -8) + 0, (long) 0L); + local5 = local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break label_2; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + } + return; + } + + public static long[] call_1003(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1003(arg0, arg1, memory, instance); + return null; + } + + public static int func_1004(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + label_1: { + label_2: { + arg1 = memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 148) + (arg1 << 2)) + 0); + local3 = memory.readInt((int) (arg1 + 76) < 0 ? (arg1 + 76) : (arg1 + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, memory.readInt((int) (arg1 + 80) < 0 ? (arg1 + 80) : (arg1 + 80) + 0)) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + local3 = (local3 + 12); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 76, (int) local3); + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg1 + 72)); + instance.getMachine().call(1005, callArgs_0); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 76); + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) (local3 + -12)); + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(884, callArgs_1); + return ((int) callResult_1[0]); + } + + public static long[] call_1004(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1004(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1005(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local1 - local2), 12); + local4 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 357913942) != 0) { + break label_4; + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 12); + local6 = (local5 << 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local4) != 0 ? local6 : local4) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 357913942) != 0) { + break label_3; + } + local4 = (local4 * 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local5 = ((int) callResult_0[0]); + local3 = (local5 + (local3 * 12)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + local6 = (local5 + local4); + local7 = (local3 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local1) != 0) { + break label_2; + } + local4 = (local1 + -12); + local3 = (local3 + -12); + label_5: while (true) { + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + memory.writeLong((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (long) 0L); + local3 = (local3 + -12); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local2, local4); + local4 = (local4 + -12); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local3 + 12)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local2) != 0) { + break label_1; + } + label_6: while (true) { + label_7: { + local5 = (local2 + -12); + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_7; + } + label_8: while (true) { + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local4 = local3; + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + memory.writeLong((int) (local2 + -8) < 0 ? (local2 + -8) : (local2 + -8) + 0, (long) 0L); + local2 = local5; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_9; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_4); + } + return; + } + + public static long[] call_1005(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1005(arg0, memory, instance); + return null; + } + + public static int func_1006(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0), memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0)) != 0) { + break label_1; + } + return 0; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 11636); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + return 1; + } + + public static long[] call_1006(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1006(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1007(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1007(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1007(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1008(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1008(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1008(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1009(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1009(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1009(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1010(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 172); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(((memory.readInt((int) (local2 + 180) < 0 ? (local2 + 180) : (local2 + 180) + 0) - local3) >> 2), arg1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_1; + } + arg0 = memory.readInt((int) (local2 + 176) < 0 ? (local2 + 176) : (local2 + 176) + 0); + arg1 = (arg1 << 2); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (local4 + arg1); + local4 = (local4 + ((arg0 - local3) & -4)); + arg1 = local4; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg0) != 0) { + break label_3; + } + arg1 = local4; + label_4: while (true) { + arg1 = (arg1 + -4); + arg0 = (arg0 + -4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 172, (int) arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1010(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1010(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1011(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local4 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local4)); + local5 = (arg0 + 4); + local6 = memory.readInt((int) (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) < 0 ? (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) : (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) + 0); + local7 = (arg0 + 32); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local8); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local9 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 112); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local10 = ((int) callResult_1[0]); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 12, (int) local8); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 4, (long) 0L); + memory.writeByte((int) local10 < 0 ? local10 : local10 + 51, (byte) (0)); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 32, (long) 8L); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) 49816); + memory.writeLong((int) (local10 + 24) < 0 ? (local10 + 24) : (local10 + 24) + 0, (long) 0L); + memory.writeI32((int) (local10 + 20) < 0 ? (local10 + 20) : (local10 + 20) + 0, (int) local6); + memory.writeI32((int) (local10 + 16) < 0 ? (local10 + 16) : (local10 + 16) + 0, (int) local9); + memory.writeByte((int) (local10 + 40) < 0 ? (local10 + 40) : (local10 + 40) + 0, (byte) (0)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local10 + 52)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + local6 = ((int) callResult_2[0]); + memory.writeLong((int) (local10 + 104) < 0 ? (local10 + 104) : (local10 + 104) + 0, (long) 0L); + memory.writeLong((int) (local10 + 96) < 0 ? (local10 + 96) : (local10 + 96) + 0, (long) 0L); + memory.writeLong((int) (local10 + 88) < 0 ? (local10 + 88) : (local10 + 88) + 0, (long) 0L); + local5 = memory.readInt((int) (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) < 0 ? (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) : (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 8) + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) 0L); + local7 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local7); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local8 = ((int) callResult_3[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local5); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local7); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local4); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local4 + 24)); + long[] callResult_4 = instance.getMachine().call(155, callArgs_4); + arg2 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(158, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg2); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 36, (int) (arg3 & 1)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local10); + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + instance.getMachine().call(136, callArgs_7); + instance.global(0).setValue(((long) (local4 + 64))); + return 0; + } + + public static long[] call_1011(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1011(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1012(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) (memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 172) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 172) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 172) + (arg1 << 2)) + 0) + 52)); + callArgs_0[1] = ((long) 1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(884, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_1012(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1012(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1013(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0), memory.readInt((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0)) != 0) { + break label_1; + } + return 0; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 11636); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + return 1; + } + + public static long[] call_1013(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1013(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1014(int arg0, int arg1, int arg2, long arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + arg1 = memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 172) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 172) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 172) + (arg1 << 2)) + 0); + local4 = (arg1 + 64); + label_1: { + label_2: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 64); + local6 = (memory.readInt((int) (arg1 + 68) < 0 ? (arg1 + 68) : (arg1 + 68) + 0) - local5); + arg0 = (int) arg3; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, arg0) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg0 - local6)); + callArgs_0[0] = ((long) local4); + instance.getMachine().call(84, callArgs_0); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local6, arg0) != 0) { + break label_1; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 68, (int) (local5 + arg0)); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(arg3) != 0) { + break label_3; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg0); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + long[] callResult_1 = instance.getMachine().call(1890, callArgs_1); + } + return 0; + } + + public static long[] call_1014(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + int result = Wat2WasmMachine.func_1014(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1015(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1015(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1015(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1016(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1016(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1016(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1017(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1017(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1017(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1018(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1018(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1018(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1019(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1019(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1019(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1020(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1020(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1020(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1021(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1021(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1021(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1022(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)) != 0) { + break label_1; + } + local3 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (int) (local3 >>> 32L)); + callArgs_0[1] = ((long) (int) local3); + callArgs_0[0] = ((long) local2); + instance.getMachine().call(1023, callArgs_0); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg1 = (arg0 + 20); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 31), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_1); + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1022(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1022(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1023(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + memory.writeShort((int) local3 < 0 ? local3 : local3 + 16, (short) (36)); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 27, (byte) (1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 2147483632) != 0) { + break label_1; + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 10) != 0) { + break label_3; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 11, (byte) (arg2)); + local4 = local3; + break label_2; + } + local5 = ((arg2 | 15) + 1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) (local5 | -2147483648)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg2); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1891, callArgs_1); + memory.writeByte((int) (((int) callResult_1[0]) + arg2) < 0 ? (((int) callResult_1[0]) + arg2) : (((int) callResult_1[0]) + arg2) + 0, (byte) (0)); + arg2 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 11) & 0xFF); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg2), 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 4) : arg2)); + callArgs_2[1] = ((long) (local4 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : local3)); + callArgs_2[0] = ((long) (local3 + 16)); + long[] callResult_2 = instance.getMachine().call(1652, callArgs_2); + arg2 = ((int) callResult_2[0]); + local6 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + arg2 = (arg2 + 8); + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) local6); + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) local4); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), -1) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_3); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 27), -1) != 0) { + break label_5; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 16)); + instance.getMachine().call(1777, callArgs_4); + } + instance.global(0).setValue(((long) (local3 + 32))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1023(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1023(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1024(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1024(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1024(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1025(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = 0; + label_1: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local4 = ((memory.readInt((int) (local4 + 80) < 0 ? (local4 + 80) : (local4 + 80) + 0) - memory.readInt((int) local4 < 0 ? local4 : local4 + 76)) >> 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, arg1) != 0) { + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) 30309); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_1025(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1025(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1026(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + local4 = 0; + label_1: { + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local5, 4294967296L) != 0) { + break label_1; + } + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg2 = memory.readInt((int) local4 < 0 ? local4 : local4 + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (local4 + 80) < 0 ? (local4 + 80) : (local4 + 80) + 0) - arg2) >> 2), arg1) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) 5354); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + local4 = 1; + break label_1; + } + arg2 = memory.readInt((int) (arg2 + (arg1 << 2)) < 0 ? (arg2 + (arg1 << 2)) : (arg2 + (arg1 << 2)) + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (int) (local5 >>> 32L)); + callArgs_1[1] = ((long) (int) local5); + callArgs_1[0] = ((long) (local3 + 8)); + instance.getMachine().call(1023, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 8)); + callArgs_2[1] = ((long) (local4 + 228)); + callArgs_2[0] = ((long) (local3 + 32)); + instance.getMachine().call(1027, callArgs_2); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 19), -1) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 8)); + instance.getMachine().call(1777, callArgs_3); + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local3 + 32), arg2) != 0) { + break label_4; + } + local6 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 43) & 0xFF); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg2 < 0 ? arg2 : arg2 + 11), 0) != 0) { + break label_5; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0) { + break label_6; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 32)); + memory.writeI32((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (int) memory.readInt((int) ((local3 + 32) + 8) < 0 ? ((local3 + 32) + 8) : ((local3 + 32) + 8) + 0)); + break label_4; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 36)); + callArgs_4[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(1659, callArgs_4); + break label_4; + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local4 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 36) : local6)); + callArgs_5[1] = ((long) (local4 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 32) : (local3 + 32))); + callArgs_5[0] = ((long) arg2); + long[] callResult_5 = instance.getMachine().call(1658, callArgs_5); + } + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local4 = 0; + memory.writeI32((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (int) 0); + memory.writeLong((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) arg1); + arg1 = (arg2 + 228); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local3 + 8)); + callArgs_6[2] = ((long) (local3 + 32)); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) (local3 + 48)); + instance.getMachine().call(137, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(138, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local3 + 64))); + return local4; + } + + public static long[] call_1026(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1026(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1027(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg2 < 0 ? arg2 : arg2 + 11), 0) != 0) { + break label_2; + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) memory.readInt((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4)); + callArgs_0[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1647, callArgs_0); + } + label_3: { + label_4: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg0); + callArgs_1[0] = ((long) arg1); + long[] callResult_1 = instance.getMachine().call(1093, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_1[0])) != 0) { + break label_4; + } + local4 = ((local3 + 24) + 8); + local5 = (arg0 + 4); + local6 = (local5 + 3); + local7 = 1; + label_5: while (true) { + local8 = ((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 11) & 0xFF); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local8), 0); + local10 = (local9 != 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) : local8); + local8 = (local10 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 2147483632) != 0) { + break label_3; + } + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 10) != 0) { + break label_7; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) 0L); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 35, (byte) (local8)); + local11 = (local3 + 24); + break label_6; + } + local12 = ((local8 | 15) + 1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local12); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local11 = ((int) callResult_2[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) local8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local11); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) (local12 | -2147483648)); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local10); + callArgs_3[1] = ((long) (local9 != 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) : arg2)); + callArgs_3[0] = ((long) local11); + long[] callResult_3 = instance.getMachine().call(1891, callArgs_3); + memory.writeShort((int) (((int) callResult_3[0]) + local10) < 0 ? (((int) callResult_3[0]) + local10) : (((int) callResult_3[0]) + local10) + 0, (short) (46)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local7); + callArgs_4[0] = ((long) (local3 + 8)); + instance.getMachine().call(1664, callArgs_4); + local8 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 19) & 0xFF); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local8), 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local10 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 12) : local8)); + callArgs_5[1] = ((long) (local10 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 8) : (local3 + 8))); + callArgs_5[0] = ((long) (local3 + 24)); + long[] callResult_5 = instance.getMachine().call(1652, callArgs_5); + local8 = ((int) callResult_5[0]); + local10 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + local11 = memory.readInt((int) (local8 + 7) < 0 ? (local8 + 7) : (local8 + 7) + 0); + memory.writeI32((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (int) 0); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local12 = memory.readInt((int) local8 < 0 ? local8 : local8 + 4); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) local12); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 43, (int) local11); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11), -1) != 0) { + break label_8; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(1777, callArgs_6); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local9); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 40)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (local10)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 43)); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 19), -1) != 0) { + break label_9; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 8)); + instance.getMachine().call(1777, callArgs_7); + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 35), -1) != 0) { + break label_10; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 24)); + instance.getMachine().call(1777, callArgs_8); + } + local7 = (local7 + 1); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) arg0); + callArgs_9[0] = ((long) arg1); + long[] callResult_9 = instance.getMachine().call(1093, callArgs_9); + if (((int) callResult_9[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + instance.global(0).setValue(((long) (local3 + 48))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1027(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1027(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1028(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1028(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1028(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1029(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1029(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1029(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1030(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = 0; + label_1: { + arg1 = memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg1 + 116)); + long[] callResult_0 = instance.getMachine().call(130, callArgs_0); + arg1 = (((memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0) - memory.readInt((int) (arg1 + 52) < 0 ? (arg1 + 52) : (arg1 + 52) + 0)) >> 3) + ((int) callResult_0[0])); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, arg2) != 0) { + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg2); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local3); + callArgs_1[1] = ((long) 29954); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_1); + local4 = 1; + } + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_1030(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1030(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1031(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + long local5 = 0L; + local4 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local4)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4)) != 0) { + break label_1; + } + arg1 = memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) + 0); + local5 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (int) (local5 >>> 32L)); + callArgs_0[1] = ((long) (int) local5); + callArgs_0[0] = ((long) (local4 + 32)); + instance.getMachine().call(1023, callArgs_0); + arg3 = (arg1 + 128); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local4 + 32)); + callArgs_1[1] = ((long) arg3); + callArgs_1[0] = ((long) (local4 + 48)); + instance.getMachine().call(1027, callArgs_1); + memory.writeI32((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (int) 0); + memory.writeLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) arg2); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 8)); + callArgs_2[1] = ((long) (local4 + 48)); + callArgs_2[0] = ((long) arg3); + long[] callResult_2 = instance.getMachine().call(1032, callArgs_2); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 59), -1) != 0) { + break label_2; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 48)); + instance.getMachine().call(1777, callArgs_3); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 32)); + instance.getMachine().call(1777, callArgs_4); + } + instance.global(0).setValue(((long) (local4 + 64))); + return 0; + } + + public static long[] call_1031(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1031(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1032(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local3 = 0; + long local4 = 0L; + int local5 = 0; + int local6 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 44); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local3 = ((int) callResult_0[0]); + local4 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + arg1 = (arg1 + 8); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local5); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) local4); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeLong((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (long) memory.readLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + arg2 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 19); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg2, 0); + arg1 = (local5 != 0 ? (int) local4 : (local3 + 8)); + label_1: { + label_2: { + local6 = (local5 != 0 ? memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0) : (arg2 & 255)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 4) != 0) { + break label_2; + } + arg2 = local6; + local5 = local6; + break label_1; + } + label_3: { + label_4: { + local5 = (local6 + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local5 & 4)) != 0) { + break label_4; + } + arg2 = local6; + break label_3; + } + arg2 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) * 1540483477); + arg2 = ((((arg2 >>> 24) ^ arg2) * 1540483477) ^ (local6 * 1540483477)); + arg1 = (arg1 + 4); + local6 = local5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 4) != 0) { + break label_1; + } + local5 = local6; + label_5: while (true) { + local6 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) * 1540483477); + _snap_0 = local6; + local6 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) * 1540483477); + arg2 = ((((_snap_0 >>> 24) ^ _snap_0) * 1540483477) ^ (((((local6 >>> 24) ^ local6) * 1540483477) ^ (arg2 * 1540483477)) * 1540483477)); + arg1 = (arg1 + 8); + local5 = (local5 + -8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + label_6: { + label_7: { + label_8: { + label_9: { + switch((local5 + -1)) { + case 0: + { + break label_7; + } + case 1: + { + break label_8; + } + case 2: + { + break label_9; + } + default: + { + break label_6; + } + } + } + arg2 = ((((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 2) & 0xFF) << 16) ^ arg2); + } + arg2 = ((((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 1) & 0xFF) << 8) ^ arg2); + } + arg2 = ((arg2 ^ ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)) * 1540483477); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + arg1 = (((arg2 >>> 13) ^ arg2) * 1540483477); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) ((arg1 >>> 15) ^ arg1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(138, callArgs_1); + return ((int) callResult_1[0]); + } + + public static long[] call_1032(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1032(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1033(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1033(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1033(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1034(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1034(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1034(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1035(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + long local5 = 0L; + int local6 = 0; + int local7 = 0; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + switch((arg1 + -4)) { + case 0: + { + break label_8; + } + case 1: + { + break label_5; + } + case 2: + { + break label_3; + } + case 3: + { + break label_6; + } + case 4: + { + break label_2; + } + case 5: + { + break label_4; + } + case 6: + { + break label_1; + } + case 7: + { + break label_7; + } + default: + { + break label_1; + } + } + } + local5 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local5, 4294967296L) != 0) { + break label_1; + } + label_9: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (arg1 + 128) < 0 ? (arg1 + 128) : (arg1 + 128) + 0) - arg3) >> 2), arg2) != 0) { + break label_9; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 64, (int) arg2); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local4 + 64)); + callArgs_0[1] = ((long) 5454); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + break label_1; + } + arg3 = memory.readInt((int) (arg3 + (arg2 << 2)) < 0 ? (arg3 + (arg2 << 2)) : (arg3 + (arg2 << 2)) + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (int) (local5 >>> 32L)); + callArgs_1[1] = ((long) (int) local5); + callArgs_1[0] = ((long) (local4 + 104)); + instance.getMachine().call(1023, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 + 104)); + callArgs_2[1] = ((long) (arg1 + 288)); + callArgs_2[0] = ((long) (local4 + 128)); + instance.getMachine().call(1027, callArgs_2); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 115), -1) != 0) { + break label_10; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 104)); + instance.getMachine().call(1777, callArgs_3); + } + label_11: { + arg1 = (arg3 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local4 + 128), arg1) != 0) { + break label_11; + } + local6 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 139) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6); + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg3 < 0 ? arg3 : arg3 + 35), 0) != 0) { + break label_12; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0) != 0) { + break label_13; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 128)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) ((local4 + 128) + 8) < 0 ? ((local4 + 128) + 8) : ((local4 + 128) + 8) + 0)); + break label_11; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 132)); + callArgs_4[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(1659, callArgs_4); + break label_11; + } + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (arg3 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 132) : local6)); + callArgs_5[1] = ((long) (arg3 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 128) : (local4 + 128))); + callArgs_5[0] = ((long) arg1); + long[] callResult_5 = instance.getMachine().call(1658, callArgs_5); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeI32((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0, (int) 0); + memory.writeLong((int) (local4 + 112) < 0 ? (local4 + 112) : (local4 + 112) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 124, (int) arg2); + arg2 = (arg1 + 288); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local4 + 104)); + callArgs_6[2] = ((long) (local4 + 128)); + callArgs_6[1] = ((long) arg2); + callArgs_6[0] = ((long) (local4 + 144)); + instance.getMachine().call(137, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 144)); + callArgs_7[0] = ((long) arg2); + long[] callResult_7 = instance.getMachine().call(138, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 139), -1) != 0) { + break label_1; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + instance.getMachine().call(1777, callArgs_8); + break label_1; + } + local5 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local5, 4294967296L) != 0) { + break label_1; + } + label_14: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (arg1 + 68) < 0 ? (arg1 + 68) : (arg1 + 68) + 0) - arg3) >> 2), arg2) != 0) { + break label_14; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 80, (int) arg2); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local4 + 80)); + callArgs_9[1] = ((long) 5432); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_9); + break label_1; + } + arg3 = memory.readInt((int) (arg3 + (arg2 << 2)) < 0 ? (arg3 + (arg2 << 2)) : (arg3 + (arg2 << 2)) + 0); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) (int) (local5 >>> 32L)); + callArgs_10[1] = ((long) (int) local5); + callArgs_10[0] = ((long) (local4 + 104)); + instance.getMachine().call(1023, callArgs_10); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local4 + 104)); + callArgs_11[1] = ((long) (arg1 + 208)); + callArgs_11[0] = ((long) (local4 + 128)); + instance.getMachine().call(1027, callArgs_11); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 115), -1) != 0) { + break label_15; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 104)); + instance.getMachine().call(1777, callArgs_12); + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local4 + 128), arg3) != 0) { + break label_16; + } + local7 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 139) & 0xFF); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local7); + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg3 < 0 ? arg3 : arg3 + 11), 0) != 0) { + break label_17; + } + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_18; + } + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 128)); + memory.writeI32((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (int) memory.readInt((int) ((local4 + 128) + 8) < 0 ? ((local4 + 128) + 8) : ((local4 + 128) + 8) + 0)); + break label_16; + } + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 132)); + callArgs_13[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + callArgs_13[0] = ((long) arg3); + long[] callResult_13 = instance.getMachine().call(1659, callArgs_13); + break label_16; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0); + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) (arg1 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 132) : local7)); + callArgs_14[1] = ((long) (arg1 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 128) : (local4 + 128))); + callArgs_14[0] = ((long) arg3); + long[] callResult_14 = instance.getMachine().call(1658, callArgs_14); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeI32((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0, (int) 0); + memory.writeLong((int) (local4 + 112) < 0 ? (local4 + 112) : (local4 + 112) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 124, (int) arg2); + arg2 = (arg1 + 208); + long[] callArgs_15 = new long[4]; + callArgs_15[3] = ((long) (local4 + 104)); + callArgs_15[2] = ((long) (local4 + 128)); + callArgs_15[1] = ((long) arg2); + callArgs_15[0] = ((long) (local4 + 144)); + instance.getMachine().call(137, callArgs_15); + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 144)); + callArgs_16[0] = ((long) arg2); + long[] callResult_16 = instance.getMachine().call(138, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 139), -1) != 0) { + break label_1; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + instance.getMachine().call(1777, callArgs_17); + break label_1; + } + local5 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 96, (long) local5); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 56, (long) local5); + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) (local4 + 56)); + callArgs_18[1] = ((long) arg2); + callArgs_18[0] = ((long) arg0); + long[] callResult_18 = instance.getMachine().call(1036, callArgs_18); + break label_1; + } + local5 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 88, (long) local5); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 48, (long) local5); + long[] callArgs_19 = new long[3]; + callArgs_19[2] = ((long) (local4 + 48)); + callArgs_19[1] = ((long) arg2); + callArgs_19[0] = ((long) arg0); + long[] callResult_19 = instance.getMachine().call(1037, callArgs_19); + break label_1; + } + local5 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local5, 4294967296L) != 0) { + break label_1; + } + label_19: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 172); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (arg1 + 176) < 0 ? (arg1 + 176) : (arg1 + 176) + 0) - arg3) >> 2), arg2) != 0) { + break label_19; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) arg2); + long[] callArgs_20 = new long[3]; + callArgs_20[2] = ((long) (local4 + 32)); + callArgs_20[1] = ((long) 5294); + callArgs_20[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_20); + break label_1; + } + arg3 = memory.readInt((int) (arg3 + (arg2 << 2)) < 0 ? (arg3 + (arg2 << 2)) : (arg3 + (arg2 << 2)) + 0); + long[] callArgs_21 = new long[3]; + callArgs_21[2] = ((long) (int) (local5 >>> 32L)); + callArgs_21[1] = ((long) (int) local5); + callArgs_21[0] = ((long) (local4 + 104)); + instance.getMachine().call(1023, callArgs_21); + long[] callArgs_22 = new long[3]; + callArgs_22[2] = ((long) (local4 + 104)); + callArgs_22[1] = ((long) (arg1 + 348)); + callArgs_22[0] = ((long) (local4 + 128)); + instance.getMachine().call(1027, callArgs_22); + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 115), -1) != 0) { + break label_20; + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 104)); + instance.getMachine().call(1777, callArgs_23); + } + label_21: { + arg1 = (arg3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local4 + 128), arg1) != 0) { + break label_21; + } + local6 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 139) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6); + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg3 < 0 ? arg3 : arg3 + 15), 0) != 0) { + break label_22; + } + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0) != 0) { + break label_23; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 128)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) ((local4 + 128) + 8) < 0 ? ((local4 + 128) + 8) : ((local4 + 128) + 8) + 0)); + break label_21; + } + long[] callArgs_24 = new long[3]; + callArgs_24[2] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 132)); + callArgs_24[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + callArgs_24[0] = ((long) arg1); + long[] callResult_24 = instance.getMachine().call(1659, callArgs_24); + break label_21; + } + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0); + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) (arg3 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 132) : local6)); + callArgs_25[1] = ((long) (arg3 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 128) : (local4 + 128))); + callArgs_25[0] = ((long) arg1); + long[] callResult_25 = instance.getMachine().call(1658, callArgs_25); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeI32((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0, (int) 0); + memory.writeLong((int) (local4 + 112) < 0 ? (local4 + 112) : (local4 + 112) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 124, (int) arg2); + arg2 = (arg1 + 348); + long[] callArgs_26 = new long[4]; + callArgs_26[3] = ((long) (local4 + 104)); + callArgs_26[2] = ((long) (local4 + 128)); + callArgs_26[1] = ((long) arg2); + callArgs_26[0] = ((long) (local4 + 144)); + instance.getMachine().call(137, callArgs_26); + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 144)); + callArgs_27[0] = ((long) arg2); + long[] callResult_27 = instance.getMachine().call(138, callArgs_27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 139), -1) != 0) { + break label_1; + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + instance.getMachine().call(1777, callArgs_28); + break label_1; + } + local5 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local5, 4294967296L) != 0) { + break label_1; + } + label_24: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 160); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (arg1 + 164) < 0 ? (arg1 + 164) : (arg1 + 164) + 0) - arg3) >> 2), arg2) != 0) { + break label_24; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) arg2); + long[] callArgs_29 = new long[3]; + callArgs_29[2] = ((long) (local4 + 16)); + callArgs_29[1] = ((long) 5238); + callArgs_29[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_29); + break label_1; + } + arg3 = memory.readInt((int) (arg3 + (arg2 << 2)) < 0 ? (arg3 + (arg2 << 2)) : (arg3 + (arg2 << 2)) + 0); + long[] callArgs_30 = new long[3]; + callArgs_30[2] = ((long) (int) (local5 >>> 32L)); + callArgs_30[1] = ((long) (int) local5); + callArgs_30[0] = ((long) (local4 + 104)); + instance.getMachine().call(1023, callArgs_30); + long[] callArgs_31 = new long[3]; + callArgs_31[2] = ((long) (local4 + 104)); + callArgs_31[1] = ((long) (arg1 + 328)); + callArgs_31[0] = ((long) (local4 + 128)); + instance.getMachine().call(1027, callArgs_31); + label_25: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 115), -1) != 0) { + break label_25; + } + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 104)); + instance.getMachine().call(1777, callArgs_32); + } + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local4 + 128), arg3) != 0) { + break label_26; + } + local7 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 139) & 0xFF); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local7); + label_27: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg3 < 0 ? arg3 : arg3 + 11), 0) != 0) { + break label_27; + } + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0) { + break label_28; + } + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 128)); + memory.writeI32((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (int) memory.readInt((int) ((local4 + 128) + 8) < 0 ? ((local4 + 128) + 8) : ((local4 + 128) + 8) + 0)); + break label_26; + } + long[] callArgs_33 = new long[3]; + callArgs_33[2] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 132)); + callArgs_33[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + callArgs_33[0] = ((long) arg3); + long[] callResult_33 = instance.getMachine().call(1659, callArgs_33); + break label_26; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0); + long[] callArgs_34 = new long[3]; + callArgs_34[2] = ((long) (arg1 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 132) : local7)); + callArgs_34[1] = ((long) (arg1 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 128) : (local4 + 128))); + callArgs_34[0] = ((long) arg3); + long[] callResult_34 = instance.getMachine().call(1658, callArgs_34); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeI32((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0, (int) 0); + memory.writeLong((int) (local4 + 112) < 0 ? (local4 + 112) : (local4 + 112) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 124, (int) arg2); + arg2 = (arg1 + 328); + long[] callArgs_35 = new long[4]; + callArgs_35[3] = ((long) (local4 + 104)); + callArgs_35[2] = ((long) (local4 + 128)); + callArgs_35[1] = ((long) arg2); + callArgs_35[0] = ((long) (local4 + 144)); + instance.getMachine().call(137, callArgs_35); + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 144)); + callArgs_36[0] = ((long) arg2); + long[] callResult_36 = instance.getMachine().call(138, callArgs_36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 139), -1) != 0) { + break label_1; + } + long[] callArgs_37 = new long[1]; + callArgs_37[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + instance.getMachine().call(1777, callArgs_37); + break label_1; + } + local5 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local5, 4294967296L) != 0) { + break label_1; + } + label_29: { + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 148); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (arg1 + 152) < 0 ? (arg1 + 152) : (arg1 + 152) + 0) - arg3) >> 2), arg2) != 0) { + break label_29; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg2); + long[] callArgs_38 = new long[3]; + callArgs_38[2] = ((long) local4); + callArgs_38[1] = ((long) 5263); + callArgs_38[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_38); + break label_1; + } + arg3 = memory.readInt((int) (arg3 + (arg2 << 2)) < 0 ? (arg3 + (arg2 << 2)) : (arg3 + (arg2 << 2)) + 0); + long[] callArgs_39 = new long[3]; + callArgs_39[2] = ((long) (int) (local5 >>> 32L)); + callArgs_39[1] = ((long) (int) local5); + callArgs_39[0] = ((long) (local4 + 104)); + instance.getMachine().call(1023, callArgs_39); + long[] callArgs_40 = new long[3]; + callArgs_40[2] = ((long) (local4 + 104)); + callArgs_40[1] = ((long) (arg1 + 368)); + callArgs_40[0] = ((long) (local4 + 128)); + instance.getMachine().call(1027, callArgs_40); + label_30: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 115), -1) != 0) { + break label_30; + } + long[] callArgs_41 = new long[1]; + callArgs_41[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 104)); + instance.getMachine().call(1777, callArgs_41); + } + label_31: { + arg1 = (arg3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local4 + 128), arg1) != 0) { + break label_31; + } + local6 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 139) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6); + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg3 < 0 ? arg3 : arg3 + 15), 0) != 0) { + break label_32; + } + label_33: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0) != 0) { + break label_33; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 128)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) ((local4 + 128) + 8) < 0 ? ((local4 + 128) + 8) : ((local4 + 128) + 8) + 0)); + break label_31; + } + long[] callArgs_42 = new long[3]; + callArgs_42[2] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 132)); + callArgs_42[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + callArgs_42[0] = ((long) arg1); + long[] callResult_42 = instance.getMachine().call(1659, callArgs_42); + break label_31; + } + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0); + long[] callArgs_43 = new long[3]; + callArgs_43[2] = ((long) (arg3 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 132) : local6)); + callArgs_43[1] = ((long) (arg3 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 128) : (local4 + 128))); + callArgs_43[0] = ((long) arg1); + long[] callResult_43 = instance.getMachine().call(1658, callArgs_43); + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeI32((int) (local4 + 120) < 0 ? (local4 + 120) : (local4 + 120) + 0, (int) 0); + memory.writeLong((int) (local4 + 112) < 0 ? (local4 + 112) : (local4 + 112) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 104, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 124, (int) arg2); + arg2 = (arg1 + 368); + long[] callArgs_44 = new long[4]; + callArgs_44[3] = ((long) (local4 + 104)); + callArgs_44[2] = ((long) (local4 + 128)); + callArgs_44[1] = ((long) arg2); + callArgs_44[0] = ((long) (local4 + 144)); + instance.getMachine().call(137, callArgs_44); + long[] callArgs_45 = new long[2]; + callArgs_45[1] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 144)); + callArgs_45[0] = ((long) arg2); + long[] callResult_45 = instance.getMachine().call(138, callArgs_45); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 139), -1) != 0) { + break label_1; + } + long[] callArgs_46 = new long[1]; + callArgs_46[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 128)); + instance.getMachine().call(1777, callArgs_46); + } + instance.global(0).setValue(((long) (local4 + 160))); + return 0; + } + + public static long[] call_1035(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1035(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1036(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + if (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) != 0) { + break label_2; + } + arg2 = 0; + break label_1; + } + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (local4 + 92) < 0 ? (local4 + 92) : (local4 + 92) + 0) - local5) >> 2), arg1) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) 5407); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + arg2 = 1; + break label_1; + } + local5 = memory.readInt((int) (local5 + (arg1 << 2)) < 0 ? (local5 + (arg1 << 2)) : (local5 + (arg1 << 2)) + 0); + local6 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (int) (local6 >>> 32L)); + callArgs_1[1] = ((long) (int) local6); + callArgs_1[0] = ((long) (local3 + 8)); + instance.getMachine().call(1023, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 8)); + callArgs_2[1] = ((long) (local4 + 248)); + callArgs_2[0] = ((long) (local3 + 32)); + instance.getMachine().call(1027, callArgs_2); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 19), -1) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 8)); + instance.getMachine().call(1777, callArgs_3); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local3 + 32), local5) != 0) { + break label_5; + } + local4 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 43) & 0xFF); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 11), 0) != 0) { + break label_6; + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg2, 0) != 0) { + break label_7; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 32)); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) ((local3 + 32) + 8) < 0 ? ((local3 + 32) + 8) : ((local3 + 32) + 8) + 0)); + break label_5; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 36)); + callArgs_4[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1659, callArgs_4); + break label_5; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg2, 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (arg2 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 36) : local4)); + callArgs_5[1] = ((long) (arg2 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 32) : (local3 + 32))); + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(1658, callArgs_5); + } + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg2 = 0; + memory.writeI32((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (int) 0); + memory.writeLong((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) arg1); + arg1 = (arg0 + 248); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local3 + 8)); + callArgs_6[2] = ((long) (local3 + 32)); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) (local3 + 48)); + instance.getMachine().call(137, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(138, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local3 + 64))); + return arg2; + } + + public static long[] call_1036(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1036(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1037(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + if (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) != 0) { + break label_2; + } + arg2 = 0; + break label_1; + } + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 136); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (local4 + 140) < 0 ? (local4 + 140) : (local4 + 140) + 0) - local5) >> 2), arg1) != 0) { + break label_3; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local3); + callArgs_0[1] = ((long) 5477); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + arg2 = 1; + break label_1; + } + local5 = memory.readInt((int) (local5 + (arg1 << 2)) < 0 ? (local5 + (arg1 << 2)) : (local5 + (arg1 << 2)) + 0); + local6 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (int) (local6 >>> 32L)); + callArgs_1[1] = ((long) (int) local6); + callArgs_1[0] = ((long) (local3 + 8)); + instance.getMachine().call(1023, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local3 + 8)); + callArgs_2[1] = ((long) (local4 + 308)); + callArgs_2[0] = ((long) (local3 + 32)); + instance.getMachine().call(1027, callArgs_2); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 19), -1) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 8)); + instance.getMachine().call(1777, callArgs_3); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local3 + 32), local5) != 0) { + break label_5; + } + local4 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 43) & 0xFF); + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 11), 0) != 0) { + break label_6; + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg2, 0) != 0) { + break label_7; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 32)); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) ((local3 + 32) + 8) < 0 ? ((local3 + 32) + 8) : ((local3 + 32) + 8) + 0)); + break label_5; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 36)); + callArgs_4[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + callArgs_4[0] = ((long) local5); + long[] callResult_4 = instance.getMachine().call(1659, callArgs_4); + break label_5; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg2, 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (arg2 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 36) : local4)); + callArgs_5[1] = ((long) (arg2 != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 32) : (local3 + 32))); + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(1658, callArgs_5); + } + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg2 = 0; + memory.writeI32((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (int) 0); + memory.writeLong((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) arg1); + arg1 = (arg0 + 308); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local3 + 8)); + callArgs_6[2] = ((long) (local3 + 32)); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) (local3 + 48)); + instance.getMachine().call(137, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + callArgs_7[0] = ((long) arg1); + long[] callResult_7 = instance.getMachine().call(138, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local3 + 64))); + return arg2; + } + + public static long[] call_1037(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1037(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1038(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1038(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1038(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1039(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1039(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1039(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1040(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1040(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1040(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1041(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1041(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1041(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1042(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1042(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1042(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1043(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1043(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1043(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1044(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1044(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1044(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1045(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1045(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1045(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1046(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1046(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1046(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1047(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1047(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1047(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1048(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1048(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1048(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1049(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1049(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1049(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1050(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1050(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1050(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1051(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1051(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1051(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1052(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1052(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1052(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1053(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1053(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1053(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1054(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1054(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1054(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1055(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1055(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1055(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1056(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1056(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1056(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1057(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + long local9 = 0L; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local4 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) < 0 ? (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) : (memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0) + 8) + 0); + local6 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local7 = ((int) callResult_0[0]); + label_1: { + local8 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + local9 = (local8 >>> 32L); + arg1 = (int) local9; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 2147483632) != 0) { + break label_1; + } + local10 = (int) local8; + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 10) != 0) { + break label_3; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 11, (byte) (int) (local9)); + local11 = local4; + break label_2; + } + local12 = ((arg1 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local12); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local11 = ((int) callResult_1[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) (local12 | -2147483648)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local11); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg1); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) local10); + callArgs_2[0] = ((long) local11); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + arg1) < 0 ? (((int) callResult_2[0]) + arg1) : (((int) callResult_2[0]) + arg1) + 0, (byte) (0)); + memory.writeLong((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0, (long) 0L); + memory.writeI32((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (int) local5); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) local7); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) local6); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) 0L); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg3, -1) != 0) { + break label_1; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg3); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg1 = ((int) callResult_3[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg1); + local11 = (arg1 + arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) local11); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) local11); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg3); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(1890, callArgs_4); + } + label_5: { + label_6: { + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg1 = memory.readInt((int) (arg3 + 200) < 0 ? (arg3 + 200) : (arg3 + 200) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, memory.readInt((int) (arg3 + 204) < 0 ? (arg3 + 204) : (arg3 + 204) + 0)) != 0) { + break label_6; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + local11 = (local4 + 8); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) local11 < 0 ? local11 : local11 + 0)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 12, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 12)); + memory.writeI32((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 20)); + arg0 = (local4 + 24); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 24, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeLong((int) (arg1 + 32) < 0 ? (arg1 + 32) : (arg1 + 32) + 0, (long) memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0)); + memory.writeI32((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0, (int) memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0)); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 200, (int) (arg1 + 44)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) 0); + break label_5; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) (arg3 + 196)); + instance.getMachine().call(1058, callArgs_5); + arg1 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) arg1); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_6); + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_7; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_7); + } + instance.global(0).setValue(((long) (local4 + 48))); + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1057(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1057(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1058(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + long local7 = 0L; + long local8 = 0L; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2), 44); + local4 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 97612894) != 0) { + break label_4; + } + label_5: { + label_6: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 44); + local5 = (local2 << 1); + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 48806446) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, local4) != 0 ? local5 : local4) : 97612893); + if (local2 != 0) { + break label_6; + } + local5 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 97612894) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local2 * 44)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local5 = ((int) callResult_0[0]); + } + local6 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + local4 = (arg1 + 16); + local7 = memory.readLong((int) local4 < 0 ? local4 : local4 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + local4 = (arg1 + 8); + local8 = memory.readLong((int) local4 < 0 ? local4 : local4 + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + local4 = (local5 + (local3 * 44)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) local6); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 24)); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) local8); + memory.writeLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (long) local7); + memory.writeLong((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (long) memory.readLong((int) (arg1 + 32) < 0 ? (arg1 + 32) : (arg1 + 32) + 0)); + memory.writeI32((int) (local4 + 40) < 0 ? (local4 + 40) : (local4 + 40) + 0, (int) memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0)); + local9 = (local5 + (local2 * 44)); + local10 = (local4 + 44); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local11, arg1) != 0) { + break label_2; + } + label_7: while (true) { + local5 = (local4 + -44); + local2 = (arg1 + -44); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + local3 = (local2 + 8); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + memory.writeI32((int) (local4 + -28) < 0 ? (local4 + -28) : (local4 + -28) + 0, (int) memory.readInt((int) (arg1 + -28) < 0 ? (arg1 + -28) : (arg1 + -28) + 0)); + local3 = (arg1 + -32); + memory.writeI32((int) (local4 + -32) < 0 ? (local4 + -32) : (local4 + -32) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + local12 = (arg1 + -24); + memory.writeI32((int) (local4 + -24) < 0 ? (local4 + -24) : (local4 + -24) + 0, (int) memory.readInt((int) local12 < 0 ? local12 : local12 + 0)); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + local4 = (local4 + -20); + arg1 = (arg1 + -20); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + arg1 = local2; + local4 = local5; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local9); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local10); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_1; + } + local4 = (local4 + -44); + label_8: while (true) { + label_9: { + local2 = memory.readInt((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_9; + } + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) local2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local4 + 11) < 0 ? (local4 + 11) : (local4 + 11) + 0), -1) != 0) { + break label_10; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_2); + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local4); + local4 = (local4 + -44); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local4); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_11; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_5); + } + return; + } + + public static long[] call_1058(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1058(arg0, arg1, memory, instance); + return null; + } + + public static int func_1059(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1059(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1059(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1060(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1060(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1060(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1061(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1061(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1061(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1062(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local7 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local7)); + local8 = 0; + label_1: { + if (((arg2 & 16) | arg5) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4)) != 0) { + break label_1; + } + label_2: { + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg2 = memory.readInt((int) local8 < 0 ? local8 : local8 + 172); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (local8 + 176) < 0 ? (local8 + 176) : (local8 + 176) + 0) - arg2) >> 2), arg4) != 0) { + break label_2; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) arg4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local7); + callArgs_0[1] = ((long) 5294); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + local8 = 1; + break label_1; + } + arg2 = memory.readInt((int) (arg2 + (arg4 << 2)) < 0 ? (arg2 + (arg4 << 2)) : (arg2 + (arg4 << 2)) + 0); + local9 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (int) (local9 >>> 32L)); + callArgs_1[1] = ((long) (int) local9); + callArgs_1[0] = ((long) (local7 + 8)); + instance.getMachine().call(1023, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local7 + 8)); + callArgs_2[1] = ((long) (local8 + 348)); + callArgs_2[0] = ((long) (local7 + 32)); + instance.getMachine().call(1027, callArgs_2); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local7 < 0 ? local7 : local7 + 19), -1) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 8)); + instance.getMachine().call(1777, callArgs_3); + } + label_4: { + local8 = (arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local7 + 32), local8) != 0) { + break label_4; + } + arg3 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 43) & 0xFF); + arg5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg3); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg2 < 0 ? arg2 : arg2 + 15), 0) != 0) { + break label_5; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg5, 0) != 0) { + break label_6; + } + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 32)); + memory.writeI32((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (int) memory.readInt((int) ((local7 + 32) + 8) < 0 ? ((local7 + 32) + 8) : ((local7 + 32) + 8) + 0)); + break label_4; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 36)); + callArgs_4[1] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 32)); + callArgs_4[0] = ((long) local8); + long[] callResult_4 = instance.getMachine().call(1659, callArgs_4); + break label_4; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg5, 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (arg2 != 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 36) : arg3)); + callArgs_5[1] = ((long) (arg2 != 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 32) : (local7 + 32))); + callArgs_5[0] = ((long) local8); + long[] callResult_5 = instance.getMachine().call(1658, callArgs_5); + } + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local8 = 0; + memory.writeI32((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0, (int) 0); + memory.writeLong((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (long) 0L); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 8, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) arg4); + arg4 = (arg2 + 348); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local7 + 8)); + callArgs_6[2] = ((long) (local7 + 32)); + callArgs_6[1] = ((long) arg4); + callArgs_6[0] = ((long) (local7 + 48)); + instance.getMachine().call(137, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 48)); + callArgs_7[0] = ((long) arg4); + long[] callResult_7 = instance.getMachine().call(138, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local7 < 0 ? local7 : local7 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 32)); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local7 + 64))); + return local8; + } + + public static long[] call_1062(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int result = Wat2WasmMachine.func_1062(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1063(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + local5 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + if (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4) != 0) { + break label_2; + } + local6 = 0; + break label_1; + } + label_3: { + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (local7 + 80) < 0 ? (local7 + 80) : (local7 + 80) + 0) - local8) >> 2), arg4) != 0) { + break label_3; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local5); + callArgs_0[1] = ((long) 5354); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + local6 = 1; + break label_1; + } + local6 = 0; + local8 = memory.readInt((int) (local8 + (arg4 << 2)) < 0 ? (local8 + (arg4 << 2)) : (local8 + (arg4 << 2)) + 0); + local9 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + if ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local9), 0) != 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 4) : local9) != 0) { + break label_1; + } + local10 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (int) (local10 >>> 32L)); + callArgs_1[1] = ((long) (int) local10); + callArgs_1[0] = ((long) (local5 + 8)); + instance.getMachine().call(1023, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local5 + 8)); + callArgs_2[1] = ((long) (local7 + 228)); + callArgs_2[0] = ((long) (local5 + 32)); + instance.getMachine().call(1027, callArgs_2); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 19), -1) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 8)); + instance.getMachine().call(1777, callArgs_3); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local5 + 32), local8) != 0) { + break label_5; + } + local6 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 43) & 0xFF); + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local8 < 0 ? local8 : local8 + 11), 0) != 0) { + break label_6; + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg3, 0) != 0) { + break label_7; + } + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 32)); + memory.writeI32((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (int) memory.readInt((int) ((local5 + 32) + 8) < 0 ? ((local5 + 32) + 8) : ((local5 + 32) + 8) + 0)); + break label_5; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 36)); + callArgs_4[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 32)); + callArgs_4[0] = ((long) local8); + long[] callResult_4 = instance.getMachine().call(1659, callArgs_4); + break label_5; + } + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg3, 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (arg3 != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 36) : local6)); + callArgs_5[1] = ((long) (arg3 != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 32) : (local5 + 32))); + callArgs_5[0] = ((long) local8); + long[] callResult_5 = instance.getMachine().call(1658, callArgs_5); + } + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local6 = 0; + memory.writeI32((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (int) 0); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) 0L); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg4); + arg4 = (arg3 + 228); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local5 + 8)); + callArgs_6[2] = ((long) (local5 + 32)); + callArgs_6[1] = ((long) arg4); + callArgs_6[0] = ((long) (local5 + 48)); + instance.getMachine().call(137, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 48)); + callArgs_7[0] = ((long) arg4); + long[] callResult_7 = instance.getMachine().call(138, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 32)); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local5 + 64))); + return local6; + } + + public static long[] call_1063(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1063(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1064(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + long local6 = 0L; + local5 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local5)); + local6 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local6); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) local6); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local5); + callArgs_0[1] = ((long) arg4); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1036, callArgs_0); + arg3 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local5 + 16))); + return arg3; + } + + public static long[] call_1064(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1064(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1065(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1065(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1065(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1066(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local5 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + if (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4) != 0) { + break label_2; + } + arg3 = 0; + break label_1; + } + label_3: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((memory.readInt((int) (local6 + 68) < 0 ? (local6 + 68) : (local6 + 68) + 0) - local7) >> 2), arg4) != 0) { + break label_3; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local5); + callArgs_0[1] = ((long) 5432); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(853, callArgs_0); + arg3 = 1; + break label_1; + } + local7 = memory.readInt((int) (local7 + (arg4 << 2)) < 0 ? (local7 + (arg4 << 2)) : (local7 + (arg4 << 2)) + 0); + local8 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (int) (local8 >>> 32L)); + callArgs_1[1] = ((long) (int) local8); + callArgs_1[0] = ((long) (local5 + 8)); + instance.getMachine().call(1023, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local5 + 8)); + callArgs_2[1] = ((long) (local6 + 208)); + callArgs_2[0] = ((long) (local5 + 32)); + instance.getMachine().call(1027, callArgs_2); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 19), -1) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 8)); + instance.getMachine().call(1777, callArgs_3); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local5 + 32), local7) != 0) { + break label_5; + } + local6 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 43) & 0xFF); + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local7 < 0 ? local7 : local7 + 11), 0) != 0) { + break label_6; + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg3, 0) != 0) { + break label_7; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 32)); + memory.writeI32((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0, (int) memory.readInt((int) ((local5 + 32) + 8) < 0 ? ((local5 + 32) + 8) : ((local5 + 32) + 8) + 0)); + break label_5; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 36)); + callArgs_4[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 32)); + callArgs_4[0] = ((long) local7); + long[] callResult_4 = instance.getMachine().call(1659, callArgs_4); + break label_5; + } + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg3, 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (arg3 != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 36) : local6)); + callArgs_5[1] = ((long) (arg3 != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 32) : (local5 + 32))); + callArgs_5[0] = ((long) local7); + long[] callResult_5 = instance.getMachine().call(1658, callArgs_5); + } + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + arg3 = 0; + memory.writeI32((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (int) 0); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) 0L); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg4); + arg4 = (arg0 + 208); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local5 + 8)); + callArgs_6[2] = ((long) (local5 + 32)); + callArgs_6[1] = ((long) arg4); + callArgs_6[0] = ((long) (local5 + 48)); + instance.getMachine().call(137, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 48)); + callArgs_7[0] = ((long) arg4); + long[] callResult_7 = instance.getMachine().call(138, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 32)); + instance.getMachine().call(1777, callArgs_8); + } + instance.global(0).setValue(((long) (local5 + 64))); + return arg3; + } + + public static long[] call_1066(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1066(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1067(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + long local6 = 0L; + local5 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local5)); + local6 = memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 8, (long) local6); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) local6); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local5); + callArgs_0[1] = ((long) arg4); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1037, callArgs_0); + arg3 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local5 + 16))); + return arg3; + } + + public static long[] call_1067(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1067(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1068(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1068(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1068(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1069(int arg0, int arg1, int arg2, long arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1069(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1069(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1070(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1070(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1070(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1071(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1071(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1071(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1072(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1072(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1072(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1073(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1073(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1073(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1074(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1074(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1074(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1075(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1075(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1075(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1076(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1076(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1076(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1077(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1077(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1077(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1078(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + local4 = (arg0 + 4); + local5 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + local6 = (arg0 + 32); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local8 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 152); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local9 = ((int) callResult_1[0]); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 32, (int) 10); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 12, (int) local7); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 4, (long) 0L); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) 50328); + memory.writeShort((int) local9 < 0 ? local9 : local9 + 47, (short) (0)); + memory.writeByte((int) local9 < 0 ? local9 : local9 + 36, (byte) (0)); + memory.writeLong((int) (local9 + 24) < 0 ? (local9 + 24) : (local9 + 24) + 0, (long) 0L); + memory.writeI32((int) (local9 + 20) < 0 ? (local9 + 20) : (local9 + 20) + 0, (int) local5); + memory.writeI32((int) (local9 + 16) < 0 ? (local9 + 16) : (local9 + 16) + 0, (int) local8); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local9 + 52)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + memory.writeLong((int) (local9 + 120) < 0 ? (local9 + 120) : (local9 + 120) + 0, (long) 0L); + memory.writeLong((int) (local9 + 112) < 0 ? (local9 + 112) : (local9 + 112) + 0, (long) 0L); + memory.writeLong((int) (local9 + 104) < 0 ? (local9 + 104) : (local9 + 104) + 0, (long) 0L); + memory.writeLong((int) (local9 + 96) < 0 ? (local9 + 96) : (local9 + 96) + 0, (long) 0L); + memory.writeLong((int) (local9 + 88) < 0 ? (local9 + 88) : (local9 + 88) + 0, (long) 0L); + memory.writeLong((int) (local9 + 132) < 0 ? (local9 + 132) : (local9 + 132) + 0, (long) 0L); + memory.writeI32((int) (local9 + 128) < 0 ? (local9 + 128) : (local9 + 128) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 140) < 0 ? (local9 + 140) : (local9 + 140) + 0, (long) 0L); + memory.writeI32((int) (local9 + 148) < 0 ? (local9 + 148) : (local9 + 148) + 0, (int) 1065353216); + local4 = memory.readInt((int) (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) < 0 ? (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) : (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 8) + 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) 0L); + local5 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local5); + long[] callResult_3 = instance.getMachine().call(1897, callArgs_3); + local6 = ((int) callResult_3[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local5); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local3); + callArgs_4[1] = ((long) arg2); + callArgs_4[0] = ((long) (local3 + 24)); + long[] callResult_4 = instance.getMachine().call(155, callArgs_4); + arg2 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) arg2); + callArgs_5[1] = ((long) (local9 + 48)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(862, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg2); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local9); + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + instance.getMachine().call(140, callArgs_7); + memory.writeByte((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 389) + 0, (byte) (1)); + instance.global(0).setValue(((long) (local3 + 64))); + return 0; + } + + public static long[] call_1078(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1078(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1079(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1079(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1079(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1080(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 60, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + return 0; + } + + public static long[] call_1080(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1080(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1081(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1081(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1081(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1082(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_1 = 0; + int _snap_0 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local3 = 0; + local4 = memory.readInt((int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) < 0 ? (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) : (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 76) + (arg1 << 2)) + 0); + label_1: { + label_2: { + local5 = memory.readInt((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0); + local6 = (arg0 + 40); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local8 = (local5 - local7); + local9 = (local8 >> 2); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local5); + arg1 = memory.readInt((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0) + arg1), (local10 != 0 ? 0 : ((local9 * 146) + -1))) != 0) { + break label_2; + } + arg1 = local5; + break label_1; + } + label_3: { + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 146) != 0) { + break label_5; + } + memory.writeI32((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0, (int) (arg1 + -146)); + local11 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + arg1 = (local7 + 4); + memory.writeI32((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (int) arg1); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0), local5) != 0) { + break label_7; + } + local7 = local5; + break label_6; + } + label_8: { + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg1, local9) != 0) { + break label_8; + } + local12 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((arg1 - local9) >> 2) + 1), -2) << 2); + local7 = (local5 - arg1); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local7); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg1 + local12)); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + local7 = (((int) callResult_0[0]) + local7); + memory.writeI32((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0, (int) local7); + arg1 = (arg0 + 40); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + local12)); + break label_6; + } + local12 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, local5) != 0 ? 1 : ((local5 - local9) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local12, 1073741824) != 0) { + break label_4; + } + local7 = (local12 << 2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local7); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local8 = ((int) callResult_1[0]); + local10 = (local8 + local7); + local13 = (local8 + (local12 & -4)); + local7 = local13; + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local5) != 0) { + break label_9; + } + local12 = (local5 - arg1); + local5 = (local12 & -4); + label_10: { + label_11: { + local14 = (local12 + -4); + local7 = (((local14 >>> 2) + 1) & 7); + if (local7 != 0) { + break label_11; + } + local12 = local13; + break label_10; + } + local12 = local13; + label_12: while (true) { + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + arg1 = (arg1 + 4); + local12 = (local12 + 4); + local7 = (local7 + -1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break; + } + } + local7 = (local13 + local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local14, 28) != 0) { + break label_9; + } + label_13: while (true) { + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local12 + 4) < 0 ? (local12 + 4) : (local12 + 4) + 0, (int) memory.readInt((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0)); + memory.writeI32((int) (local12 + 8) < 0 ? (local12 + 8) : (local12 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local12 + 12) < 0 ? (local12 + 12) : (local12 + 12) + 0, (int) memory.readInt((int) (arg1 + 12) < 0 ? (arg1 + 12) : (arg1 + 12) + 0)); + memory.writeI32((int) (local12 + 16) < 0 ? (local12 + 16) : (local12 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) (local12 + 20) < 0 ? (local12 + 20) : (local12 + 20) + 0, (int) memory.readInt((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local12 + 24) < 0 ? (local12 + 24) : (local12 + 24) + 0, (int) memory.readInt((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0)); + memory.writeI32((int) (local12 + 28) < 0 ? (local12 + 28) : (local12 + 28) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + arg1 = (arg1 + 32); + local12 = (local12 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local12) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 48, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) local8); + arg1 = (arg0 + 44); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local7); + memory.writeI32((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (int) local13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_6; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local9); + instance.getMachine().call(1777, callArgs_2); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local11); + arg1 = (arg0 + 44); + _snap_0 = arg1; + arg1 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4); + memory.writeI32((int) _snap_0 < 0 ? _snap_0 : _snap_0 + 0, (int) arg1); + break label_1; + } + label_14: { + arg1 = memory.readInt((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0); + local12 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + local11 = (arg1 - local12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local9, (local11 >> 2)) != 0) { + break label_14; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 4088); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local13 = ((int) callResult_3[0]); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, arg1) != 0) { + break label_15; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local13); + arg1 = (arg0 + 44); + _snap_1 = arg1; + arg1 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4); + memory.writeI32((int) _snap_1 < 0 ? _snap_1 : _snap_1 + 0, (int) arg1); + break label_1; + } + label_16: { + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local12, local7) != 0) { + break label_17; + } + local5 = local7; + break label_16; + } + arg1 = (local10 != 0 ? 1 : ((arg1 - local7) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_4; + } + local12 = (arg1 << 2); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local12); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local14 = ((int) callResult_4[0]); + local15 = (local14 + local12); + local5 = (local14 + ((arg1 + 3) & -4)); + local11 = local5; + label_18: { + if (local10 != 0) { + break label_18; + } + local9 = (local9 << 2); + arg1 = local5; + local12 = local7; + label_19: { + local8 = (local8 + -4); + local11 = (((local8 >>> 2) + 1) & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_19; + } + arg1 = local5; + local12 = local7; + label_20: while (true) { + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local12 < 0 ? local12 : local12 + 0)); + local12 = (local12 + 4); + arg1 = (arg1 + 4); + local11 = (local11 + -1); + if (local11 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + } + local11 = (local5 + local9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 28) != 0) { + break label_18; + } + label_21: while (true) { + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local12 < 0 ? local12 : local12 + 0)); + memory.writeI32((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0, (int) memory.readInt((int) (local12 + 4) < 0 ? (local12 + 4) : (local12 + 4) + 0)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) (local12 + 8) < 0 ? (local12 + 8) : (local12 + 8) + 0)); + memory.writeI32((int) (arg1 + 12) < 0 ? (arg1 + 12) : (arg1 + 12) + 0, (int) memory.readInt((int) (local12 + 12) < 0 ? (local12 + 12) : (local12 + 12) + 0)); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) memory.readInt((int) (local12 + 16) < 0 ? (local12 + 16) : (local12 + 16) + 0)); + memory.writeI32((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0, (int) memory.readInt((int) (local12 + 20) < 0 ? (local12 + 20) : (local12 + 20) + 0)); + memory.writeI32((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (int) memory.readInt((int) (local12 + 24) < 0 ? (local12 + 24) : (local12 + 24) + 0)); + memory.writeI32((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (int) memory.readInt((int) (local12 + 28) < 0 ? (local12 + 28) : (local12 + 28) + 0)); + local12 = (local12 + 32); + arg1 = (arg1 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_21; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) local14); + memory.writeI32((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0, (int) local15); + memory.writeI32((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0, (int) local11); + arg1 = (arg0 + 40); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_16; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_5); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + } + memory.writeI32((int) (local5 + -4) < 0 ? (local5 + -4) : (local5 + -4) + 0, (int) local13); + local12 = (arg0 + 40); + arg1 = memory.readInt((int) local12 < 0 ? local12 : local12 + 0); + local7 = (arg1 + -4); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) local7); + local5 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) arg1); + label_22: { + label_23: { + local11 = (arg0 + 44); + local12 = memory.readInt((int) local11 < 0 ? local11 : local11 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0), local12) != 0) { + break label_23; + } + local7 = local12; + break label_22; + } + label_24: { + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg1, local9) != 0) { + break label_24; + } + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((arg1 - local9) >> 2) + 1), -2) << 2); + local12 = (local12 - arg1); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local12); + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) (arg1 + local9)); + long[] callResult_6 = instance.getMachine().call(1891, callArgs_6); + local7 = (((int) callResult_6[0]) + local12); + memory.writeI32((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0, (int) local7); + arg1 = (arg0 + 40); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + local9)); + break label_22; + } + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, local12) != 0 ? 1 : ((local12 - local9) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 1073741824) != 0) { + break label_4; + } + local13 = (local7 << 2); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local13); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + local8 = ((int) callResult_7[0]); + local10 = (local8 + local13); + local13 = (local8 + (local7 & -4)); + local7 = local13; + label_25: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local12) != 0) { + break label_25; + } + local12 = (local12 - arg1); + local14 = (local12 & -4); + label_26: { + label_27: { + local15 = (local12 + -4); + local7 = (((local15 >>> 2) + 1) & 7); + if (local7 != 0) { + break label_27; + } + local12 = local13; + break label_26; + } + local12 = local13; + label_28: while (true) { + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + arg1 = (arg1 + 4); + local12 = (local12 + 4); + local7 = (local7 + -1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_28; + } + break; + } + } + local7 = (local13 + local14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local15, 28) != 0) { + break label_25; + } + label_29: while (true) { + memory.writeI32((int) local12 < 0 ? local12 : local12 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local12 + 4) < 0 ? (local12 + 4) : (local12 + 4) + 0, (int) memory.readInt((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0)); + memory.writeI32((int) (local12 + 8) < 0 ? (local12 + 8) : (local12 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local12 + 12) < 0 ? (local12 + 12) : (local12 + 12) + 0, (int) memory.readInt((int) (arg1 + 12) < 0 ? (arg1 + 12) : (arg1 + 12) + 0)); + memory.writeI32((int) (local12 + 16) < 0 ? (local12 + 16) : (local12 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeI32((int) (local12 + 20) < 0 ? (local12 + 20) : (local12 + 20) + 0, (int) memory.readInt((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0)); + memory.writeI32((int) (local12 + 24) < 0 ? (local12 + 24) : (local12 + 24) + 0, (int) memory.readInt((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0)); + memory.writeI32((int) (local12 + 28) < 0 ? (local12 + 28) : (local12 + 28) + 0, (int) memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0)); + arg1 = (arg1 + 32); + local12 = (local12 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local12) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_29; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) local8); + memory.writeI32((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0, (int) local10); + arg1 = (arg0 + 44); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local7); + memory.writeI32((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (int) local13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_22; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local9); + instance.getMachine().call(1777, callArgs_8); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local5); + arg1 = (memory.readInt((int) local11 < 0 ? local11 : local11 + 0) + 4); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) arg1); + break label_1; + } + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local12, arg1) != 0 ? 1 : (local11 >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_4; + } + local12 = (arg1 << 2); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local12); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + local13 = ((int) callResult_9[0]); + local12 = (local13 + local12); + local11 = (local13 + (local9 << 2)); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) 4088); + long[] callResult_10 = instance.getMachine().call(1776, callArgs_10); + local14 = ((int) callResult_10[0]); + label_30: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local9) != 0) { + break label_30; + } + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 1) != 0) { + break label_31; + } + local11 = (local11 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local9 + 1), -2) << 2)); + break label_30; + } + local7 = (local10 != 0 ? 1 : (local8 >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 1073741824) != 0) { + break label_4; + } + local12 = (local7 << 2); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local12); + long[] callResult_11 = instance.getMachine().call(1776, callArgs_11); + arg1 = ((int) callResult_11[0]); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local13); + instance.getMachine().call(1777, callArgs_12); + local12 = (arg1 + local12); + local11 = (arg1 + (local7 & -4)); + local7 = memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0); + local5 = memory.readInt((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0); + local13 = arg1; + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local14); + arg1 = (local11 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local5) != 0) { + break label_3; + } + local8 = (arg0 + 40); + label_32: while (true) { + label_33: { + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local13, local11) != 0) { + break label_34; + } + local9 = local11; + break label_33; + } + label_35: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local12) != 0) { + break label_35; + } + local7 = (arg1 - local11); + arg1 = (arg1 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local12 - arg1) >> 2) + 1), 2) << 2)); + local9 = (arg1 - local7); + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) local7); + callArgs_13[1] = ((long) local11); + callArgs_13[0] = ((long) local9); + long[] callResult_13 = instance.getMachine().call(1891, callArgs_13); + local13 = local11; + break label_33; + } + local12 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local11, local12) != 0 ? 1 : ((local12 - local11) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local12, 1073741824) != 0) { + break label_4; + } + local10 = (local12 << 2); + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local10); + long[] callResult_14 = instance.getMachine().call(1776, callArgs_14); + local13 = ((int) callResult_14[0]); + local9 = (local13 + ((local12 + 3) & -4)); + local7 = local9; + label_36: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local11, arg1) != 0) { + break label_36; + } + local7 = (arg1 - local11); + local14 = (local7 & -4); + arg1 = local9; + local12 = local11; + label_37: { + local15 = (local7 + -4); + local7 = (((local15 >>> 2) + 1) & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_37; + } + arg1 = local9; + local12 = local11; + label_38: while (true) { + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local12 < 0 ? local12 : local12 + 0)); + local12 = (local12 + 4); + arg1 = (arg1 + 4); + local7 = (local7 + -1); + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_38; + } + break; + } + } + local7 = (local9 + local14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local15, 28) != 0) { + break label_36; + } + label_39: while (true) { + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local12 < 0 ? local12 : local12 + 0)); + memory.writeI32((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0, (int) memory.readInt((int) (local12 + 4) < 0 ? (local12 + 4) : (local12 + 4) + 0)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) (local12 + 8) < 0 ? (local12 + 8) : (local12 + 8) + 0)); + memory.writeI32((int) (arg1 + 12) < 0 ? (arg1 + 12) : (arg1 + 12) + 0, (int) memory.readInt((int) (local12 + 12) < 0 ? (local12 + 12) : (local12 + 12) + 0)); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) memory.readInt((int) (local12 + 16) < 0 ? (local12 + 16) : (local12 + 16) + 0)); + memory.writeI32((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0, (int) memory.readInt((int) (local12 + 20) < 0 ? (local12 + 20) : (local12 + 20) + 0)); + memory.writeI32((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (int) memory.readInt((int) (local12 + 24) < 0 ? (local12 + 24) : (local12 + 24) + 0)); + memory.writeI32((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0, (int) memory.readInt((int) (local12 + 28) < 0 ? (local12 + 28) : (local12 + 28) + 0)); + local12 = (local12 + 32); + arg1 = (arg1 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_39; + } + break; + } + } + local12 = (local13 + local10); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local11); + instance.getMachine().call(1777, callArgs_15); + arg1 = local7; + } + local11 = (local9 + -4); + local5 = (local5 + -4); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) local8 < 0 ? local8 : local8 + 0), local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_32; + } + break label_3; + } + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0, (int) local12); + local7 = (arg0 + 44); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) arg1); + memory.writeI32((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (int) local11); + local12 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) local13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_1; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local12); + instance.getMachine().call(1777, callArgs_17); + arg1 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + } + label_40: { + local12 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local12, arg1) != 0) { + break label_40; + } + arg1 = (memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0) + memory.readInt((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0)); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(arg1, 146); + local3 = (memory.readInt((int) (local12 + (local7 << 2)) < 0 ? (local12 + (local7 << 2)) : (local12 + (local7 << 2)) + 0) + ((arg1 - (local7 * 146)) * 28)); + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeLong((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0, (long) 0L); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local4); + arg1 = (arg0 + 56); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 1)); + return 0; + } + + public static long[] call_1082(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1082(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1083(int arg0, int arg1, int arg2, long arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_1 = 0; + int _snap_0 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local4 = 0; + local5 = 0; + label_1: { + label_2: { + local6 = (int) arg3; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local6, -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local6); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1890, callArgs_1); + local4 = (((int) callResult_1[0]) + local6); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 56); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local6 = ((int) callResult_2[0]); + arg2 = (local6 + 20); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 44, (int) local5); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 4, (long) 0L); + memory.writeI32((int) (local6 + 52) < 0 ? (local6 + 52) : (local6 + 52) + 0, (int) local4); + memory.writeI32((int) (local6 + 48) < 0 ? (local6 + 48) : (local6 + 48) + 0, (int) local4); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 36, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 60)); + memory.writeLong((int) (local6 + 28) < 0 ? (local6 + 28) : (local6 + 28) + 0, (long) 64424509440L); + memory.writeLong((int) (local6 + 12) < 0 ? (local6 + 12) : (local6 + 12) + 0, (long) 0L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 51692); + label_3: { + _snap_0 = arg0; + arg0 = ((memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0) + memory.readInt((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0)) + -1); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(arg0, 146); + arg0 = (memory.readInt((int) (memory.readInt((int) (_snap_0 + 40) < 0 ? (_snap_0 + 40) : (_snap_0 + 40) + 0) + (local4 << 2)) < 0 ? (memory.readInt((int) (_snap_0 + 40) < 0 ? (_snap_0 + 40) : (_snap_0 + 40) + 0) + (local4 << 2)) : (memory.readInt((int) (_snap_0 + 40) < 0 ? (_snap_0 + 40) : (_snap_0 + 40) + 0) + (local4 << 2)) + 0) + ((arg0 - (local4 * 146)) * 28)); + local5 = memory.readInt((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0); + local4 = memory.readInt((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + arg1 = (arg0 + 24); + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local7 = (arg0 + 20); + _snap_1 = local5; + local5 = (arg2 + memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, _snap_1) != 0 ? 0 : (((_snap_1 - local4) << 8) + -1))) != 0) { + break label_3; + } + arg0 = (arg0 + 4); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1084, callArgs_3); + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local5 = (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + arg2); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) (arg2 + 1)); + memory.writeI32((int) (memory.readInt((int) (local4 + ((local5 >>> 8) & 16777212)) < 0 ? (local4 + ((local5 >>> 8) & 16777212)) : (local4 + ((local5 >>> 8) & 16777212)) + 0) + ((local5 & 1023) << 2)) < 0 ? (memory.readInt((int) (local4 + ((local5 >>> 8) & 16777212)) < 0 ? (local4 + ((local5 >>> 8) & 16777212)) : (local4 + ((local5 >>> 8) & 16777212)) + 0) + ((local5 & 1023) << 2)) : (memory.readInt((int) (local4 + ((local5 >>> 8) & 16777212)) < 0 ? (local4 + ((local5 >>> 8) & 16777212)) : (local4 + ((local5 >>> 8) & 16777212)) + 0) + ((local5 & 1023) << 2)) + 0, (int) local6); + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1083(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + long arg3 = args[3]; + int result = Wat2WasmMachine.func_1083(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1084(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local1 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 1024) != 0) { + break label_3; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (local2 + -1024)); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + local2 = (local2 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + label_4: { + label_5: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12), local4) != 0) { + break label_5; + } + local5 = local4; + break label_4; + } + label_6: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local2, local6) != 0) { + break label_6; + } + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local2 - local6) >> 2) + 1), -2) << 2); + local4 = (local4 - local2); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local4); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) (local2 + local6)); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + local5 = (((int) callResult_0[0]) + local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local6)); + break label_4; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0 ? 1 : ((local4 - local6) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 1073741824) != 0) { + break label_1; + } + local7 = (local5 << 2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local7); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local8 = ((int) callResult_1[0]); + local9 = (local8 + local7); + local7 = (local8 + (local5 & -4)); + local5 = local7; + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local4) != 0) { + break label_7; + } + local4 = (local4 - local2); + local10 = (local4 & -4); + label_8: { + label_9: { + local11 = (local4 + -4); + local5 = (((local11 >>> 2) + 1) & 7); + if (local5 != 0) { + break label_9; + } + local4 = local7; + break label_8; + } + local4 = local7; + label_10: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + local2 = (local2 + 4); + local4 = (local4 + 4); + local5 = (local5 + -1); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + local5 = (local7 + local10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local11, 28) != 0) { + break label_7; + } + label_11: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (int) memory.readInt((int) (local2 + 4) < 0 ? (local2 + 4) : (local2 + 4) + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + memory.writeI32((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (int) memory.readInt((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0)); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0)); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) memory.readInt((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0)); + memory.writeI32((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (int) memory.readInt((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local2 + 28) < 0 ? (local2 + 28) : (local2 + 28) + 0)); + local2 = (local2 + 32); + local4 = (local4 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_4; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 4)); + break label_2; + } + label_12: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local9 = (local2 - local4); + local6 = (local9 >> 2); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local7 = (local5 - local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, (local7 >> 2)) != 0) { + break label_12; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local5) != 0) { + break label_13; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 4096); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) ((int) callResult_3[0])); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local1 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1094, callArgs_4); + break label_2; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 4096); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) ((int) callResult_5[0])); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local1 + 8)); + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(1095, callArgs_6); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + local2 = (local2 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + label_14: { + label_15: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12), local4) != 0) { + break label_15; + } + local5 = local4; + break label_14; + } + label_16: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local2, local6) != 0) { + break label_16; + } + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local2 - local6) >> 2) + 1), -2) << 2); + local4 = (local4 - local2); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local4); + callArgs_7[1] = ((long) local2); + callArgs_7[0] = ((long) (local2 + local6)); + long[] callResult_7 = instance.getMachine().call(1891, callArgs_7); + local5 = (((int) callResult_7[0]) + local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local6)); + break label_14; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0 ? 1 : ((local4 - local6) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 1073741824) != 0) { + break label_1; + } + local7 = (local5 << 2); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local7); + long[] callResult_8 = instance.getMachine().call(1776, callArgs_8); + local8 = ((int) callResult_8[0]); + local9 = (local8 + local7); + local7 = (local8 + (local5 & -4)); + local5 = local7; + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local4) != 0) { + break label_17; + } + local4 = (local4 - local2); + local10 = (local4 & -4); + label_18: { + label_19: { + local11 = (local4 + -4); + local5 = (((local11 >>> 2) + 1) & 7); + if (local5 != 0) { + break label_19; + } + local4 = local7; + break label_18; + } + local4 = local7; + label_20: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + local2 = (local2 + 4); + local4 = (local4 + 4); + local5 = (local5 + -1); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + } + local5 = (local7 + local10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local11, 28) != 0) { + break label_17; + } + label_21: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (int) memory.readInt((int) (local2 + 4) < 0 ? (local2 + 4) : (local2 + 4) + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + memory.writeI32((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (int) memory.readInt((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0)); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0)); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) memory.readInt((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0)); + memory.writeI32((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (int) memory.readInt((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local2 + 28) < 0 ? (local2 + 28) : (local2 + 28) + 0)); + local2 = (local2 + 32); + local4 = (local4 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_21; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_14; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_9); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 4)); + break label_2; + } + memory.writeI32((int) (local1 + 24) < 0 ? (local1 + 24) : (local1 + 24) + 0, (int) (arg0 + 12)); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local5) != 0 ? 1 : (local7 >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 1073741824) != 0) { + break label_1; + } + local5 = (local7 << 2); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local5); + long[] callResult_10 = instance.getMachine().call(1776, callArgs_10); + local3 = ((int) callResult_10[0]); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) local3); + local8 = (local3 + local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 20, (int) local8); + local5 = (local3 + (local6 << 2)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local5); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) 4096); + long[] callResult_11 = instance.getMachine().call(1776, callArgs_11); + local10 = ((int) callResult_11[0]); + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local6) != 0) { + break label_22; + } + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local9, 1) != 0) { + break label_23; + } + local5 = (local5 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local6 + 1), -2) << 2)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local5); + break label_22; + } + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0 ? 1 : (local9 >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 1073741824) != 0) { + break label_1; + } + local4 = (local2 << 2); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local4); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + local6 = ((int) callResult_12[0]); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) local6); + local8 = (local6 + local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 20, (int) local8); + local5 = (local6 + (local2 & -4)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local5); + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_13); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local3 = local6; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local10); + local7 = (local5 + 4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 16, (int) local7); + local6 = local4; + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_24; + } + label_25: while (true) { + local2 = (local2 + -4); + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) local2); + callArgs_14[0] = ((long) (local1 + 8)); + instance.getMachine().call(1096, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4), local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_25; + } + break; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local8 = memory.readInt((int) local1 < 0 ? local1 : local1 + 20); + local7 = memory.readInt((int) local1 < 0 ? local1 : local1 + 16); + local5 = memory.readInt((int) local1 < 0 ? local1 : local1 + 12); + local3 = memory.readInt((int) local1 < 0 ? local1 : local1 + 8); + local6 = local2; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local8); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) local2); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 20, (int) local5); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 16, (int) local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local6); + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_26; + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 16, (int) (local4 + (((local6 - local4) + 3) & -4))); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_15); + } + instance.global(0).setValue(((long) (local1 + 32))); + return; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1084(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1084(arg0, memory, instance); + return null; + } + + public static int func_1085(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1085(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1085(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1086(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local4), 36); + local6 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 119304648) != 0) { + break label_4; + } + label_5: { + label_6: { + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local4), 36); + local7 = (local4 << 1); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, local6) != 0 ? local7 : local6) : 119304647); + if (local7 != 0) { + break label_6; + } + local4 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 119304648) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local7 * 36)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + } + local8 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local8); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local6 = ((int) callResult_1[0]); + arg3 = (local4 + (local5 * 36)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 4, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (arg3 + 12) < 0 ? (arg3 + 12) : (arg3 + 12) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) (arg3 + 20) < 0 ? (arg3 + 20) : (arg3 + 20) + 0, (int) memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 2147483632) != 0) { + break label_4; + } + local7 = (local7 * 36); + arg2 = (arg3 + 24); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 10) != 0) { + break label_8; + } + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 35, (byte) (local6)); + break label_7; + } + local9 = ((local6 | 15) + 1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local9); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + local5 = (local4 + (local5 * 36)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) (local9 | -2147483648)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg1); + memory.writeI32((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (int) local6); + arg2 = arg1; + } + arg1 = (local4 + local7); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local6); + callArgs_3[1] = ((long) local8); + callArgs_3[0] = ((long) arg2); + long[] callResult_3 = instance.getMachine().call(1891, callArgs_3); + memory.writeByte((int) (((int) callResult_3[0]) + local6) < 0 ? (((int) callResult_3[0]) + local6) : (((int) callResult_3[0]) + local6) + 0, (byte) (0)); + local8 = (arg3 + 36); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local4) != 0) { + break label_2; + } + label_9: while (true) { + arg2 = (arg3 + -36); + local6 = (local4 + -36); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (long) memory.readLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + arg3 = (arg3 + -12); + local4 = (local4 + -12); + local7 = (local4 + 8); + memory.writeI32((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 0); + local4 = local6; + arg3 = arg2; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_1; + } + local6 = (local6 + -12); + label_10: while (true) { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local6 + 11) < 0 ? (local6 + 11) : (local6 + 11) + 0), -1) != 0) { + break label_11; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + instance.getMachine().call(1777, callArgs_4); + } + arg2 = (local6 + -24); + local6 = (local6 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg3); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_12; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_7); + } + return; + } + + public static long[] call_1086(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1086(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_1087(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 47168); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1087(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1087(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1088(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 47168); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1088(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1088(arg0, memory, instance); + return null; + } + + public static void func_1089(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 47168); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1089(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1089(arg0, memory, instance); + return null; + } + + public static void func_1090(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 47356); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1090(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1090(arg0, memory, instance); + return null; + } + + public static int func_1091(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 47356); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1091(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1091(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1092(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 47356); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1092(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1092(arg0, memory, instance); + return null; + } + + public static int func_1093(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(120, callArgs_0); + arg0 = ((int) callResult_0[0]); + if (arg0 != 0) { + break label_1; + } + return 0; + } + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (local2 != 0) { + break label_2; + } + return 1; + } + arg0 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11) & 0xFF); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg0), 0); + local4 = (local3 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : arg1); + label_3: { + label_4: { + local5 = (local3 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : arg0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_4; + } + local6 = 1; + label_5: while (true) { + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 19) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3); + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, (arg0 != 0 ? memory.readInt((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0) : local3)) != 0) { + break label_3; + } + arg1 = (local2 + 8); + label_6: { + label_7: { + if (arg0 != 0) { + break label_7; + } + arg0 = local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_6; + } + label_8: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF), ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)) != 0) { + break label_3; + } + arg0 = (arg0 + 1); + arg1 = (arg1 + 1); + local3 = (local3 + -1); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_6; + } + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local5); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callResult_1 = instance.getMachine().call(1889, callArgs_1); + if (((int) callResult_1[0]) != 0) { + break label_3; + } + } + local6 = (local6 + 1); + local2 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break label_3; + } + } + local6 = 1; + label_9: while (true) { + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 19) & 0xFF); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3); + if ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? memory.readInt((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0) : local3) != 0) { + break label_3; + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 1) != 0) { + break label_10; + } + arg1 = (local2 + 8); + arg0 = local4; + label_11: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF), ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)) != 0) { + break label_3; + } + arg0 = (arg0 + 1); + arg1 = (arg1 + 1); + local3 = (local3 + -1); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + } + local6 = (local6 + 1); + local2 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + return local6; + } + + public static long[] call_1093(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1093(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1094(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12), local2) != 0) { + break label_3; + } + local3 = local2; + break label_2; + } + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local4, local5) != 0) { + break label_4; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local4 - local5) >> 2) + 1), -2) << 2); + local2 = (local2 - local4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) (local4 + local5)); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + local3 = (((int) callResult_0[0]) + local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + local5)); + break label_2; + } + local3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local2) != 0 ? 1 : ((local2 - local5) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 1073741824) != 0) { + break label_1; + } + local6 = (local3 << 2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + local8 = (local7 + local6); + local6 = (local7 + (local3 & -4)); + local3 = local6; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_5; + } + local2 = (local2 - local4); + local9 = (local2 & -4); + label_6: { + label_7: { + local10 = (local2 + -4); + local3 = (((local10 >>> 2) + 1) & 7); + if (local3 != 0) { + break label_7; + } + local2 = local6; + break label_6; + } + local2 = local6; + label_8: while (true) { + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + local4 = (local4 + 4); + local2 = (local2 + 4); + local3 = (local3 + -1); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + local3 = (local6 + local9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, 28) != 0) { + break label_5; + } + label_9: while (true) { + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local2 + 4) < 0 ? (local2 + 4) : (local2 + 4) + 0, (int) memory.readInt((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0)); + memory.writeI32((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (int) memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeI32((int) (local2 + 12) < 0 ? (local2 + 12) : (local2 + 12) + 0, (int) memory.readInt((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0)); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) memory.readInt((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + memory.writeI32((int) (local2 + 20) < 0 ? (local2 + 20) : (local2 + 20) + 0, (int) memory.readInt((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0)); + memory.writeI32((int) (local2 + 24) < 0 ? (local2 + 24) : (local2 + 24) + 0, (int) memory.readInt((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0)); + memory.writeI32((int) (local2 + 28) < 0 ? (local2 + 28) : (local2 + 28) + 0, (int) memory.readInt((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0)); + local4 = (local4 + 32); + local2 = (local2 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + 4)); + return; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1094(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1094(arg0, arg1, memory, instance); + return null; + } + + public static void func_1095(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0), local2) != 0) { + break label_3; + } + local3 = local2; + break label_2; + } + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_4; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local5 - local4) >> 2) + 1), 2) << 2); + _snap_0 = local4; + local4 = (local4 - local2); + local3 = ((_snap_0 + local5) - local4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local4); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) ((int) callResult_0[0])); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + local5)); + break label_2; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local5) != 0 ? 1 : ((local5 - local2) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 1073741824) != 0) { + break label_1; + } + local6 = (local5 << 2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + local8 = (local7 + local6); + local3 = (local7 + ((local5 + 3) & -4)); + local6 = local3; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local4) != 0) { + break label_5; + } + local6 = (local4 - local2); + local9 = (local6 & -4); + local4 = local3; + local5 = local2; + label_6: { + local10 = (local6 + -4); + local6 = (((local10 >>> 2) + 1) & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_6; + } + local4 = local3; + local5 = local2; + label_7: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + local5 = (local5 + 4); + local4 = (local4 + 4); + local6 = (local6 + -1); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + local6 = (local3 + local9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, 28) != 0) { + break label_5; + } + label_8: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (int) memory.readInt((int) (local5 + 4) < 0 ? (local5 + 4) : (local5 + 4) + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + memory.writeI32((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (int) memory.readInt((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0)); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0)); + memory.writeI32((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (int) memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0)); + local5 = (local5 + 32); + local4 = (local4 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeI32((int) (local3 + -4) < 0 ? (local3 + -4) : (local3 + -4) + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + -4)); + return; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1095(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1095(arg0, arg1, memory, instance); + return null; + } + + public static void func_1096(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0), local2) != 0) { + break label_3; + } + local3 = local2; + break label_2; + } + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, local5) != 0) { + break label_4; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((((local5 - local4) >> 2) + 1), 2) << 2); + _snap_0 = local4; + local4 = (local4 - local2); + local3 = ((_snap_0 + local5) - local4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local4); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) ((int) callResult_0[0])); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) + local5)); + break label_2; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local5) != 0 ? 1 : ((local5 - local2) >> 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 1073741824) != 0) { + break label_1; + } + local6 = (local5 << 2); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local7 = ((int) callResult_1[0]); + local8 = (local7 + local6); + local3 = (local7 + ((local5 + 3) & -4)); + local6 = local3; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local4) != 0) { + break label_5; + } + local6 = (local4 - local2); + local9 = (local6 & -4); + local4 = local3; + local5 = local2; + label_6: { + local10 = (local6 + -4); + local6 = (((local10 >>> 2) + 1) & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_6; + } + local4 = local3; + local5 = local2; + label_7: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + local5 = (local5 + 4); + local4 = (local4 + 4); + local6 = (local6 + -1); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + local6 = (local3 + local9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, 28) != 0) { + break label_5; + } + label_8: while (true) { + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0, (int) memory.readInt((int) (local5 + 4) < 0 ? (local5 + 4) : (local5 + 4) + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + memory.writeI32((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (int) memory.readInt((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0)); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) memory.readInt((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0)); + memory.writeI32((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (int) memory.readInt((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0)); + local5 = (local5 + 32); + local4 = (local4 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + memory.writeI32((int) (local3 + -4) < 0 ? (local3 + -4) : (local3 + -4) + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + -4)); + return; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1096(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1096(arg0, arg1, memory, instance); + return null; + } + + public static int func_1097(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 47372); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) (local2 + 28)); + long[] callResult_0 = instance.getMachine().call(447, callArgs_0); + memory.writeLong((int) (local2 + 88) < 0 ? (local2 + 88) : (local2 + 88) + 0, (long) 0L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 80, (long) 0L); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg0); + callArgs_1[0] = ((long) (local2 + 8)); + long[] callResult_1 = instance.getMachine().call(1098, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 47372); + label_1: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 80); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + arg1 = local4; + label_2: { + arg0 = memory.readInt((int) (local2 + 84) < 0 ? (local2 + 84) : (local2 + 84) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, arg0) != 0) { + break label_2; + } + arg1 = (arg0 + -12); + label_3: while (true) { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (arg1 + 11) < 0 ? (arg1 + 11) : (arg1 + 11) + 0), -1) != 0) { + break label_4; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_2); + } + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, arg1); + arg1 = (arg1 + -12); + if (arg0 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 80); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) local4); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_3); + } + label_5: { + arg1 = memory.readInt((int) (local2 + 68) < 0 ? (local2 + 68) : (local2 + 68) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + memory.writeI32((int) (local2 + 72) < 0 ? (local2 + 72) : (local2 + 72) + 0, (int) arg1); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_4); + } + label_6: { + arg1 = memory.readInt((int) (local2 + 56) < 0 ? (local2 + 56) : (local2 + 56) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_6; + } + memory.writeI32((int) (local2 + 60) < 0 ? (local2 + 60) : (local2 + 60) + 0, (int) arg1); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_5); + } + label_7: { + arg1 = memory.readInt((int) (local2 + 44) < 0 ? (local2 + 44) : (local2 + 44) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_7; + } + memory.writeI32((int) (local2 + 48) < 0 ? (local2 + 48) : (local2 + 48) + 0, (int) arg1); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_6); + } + label_8: { + arg1 = memory.readInt((int) (local2 + 32) < 0 ? (local2 + 32) : (local2 + 32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_8; + } + memory.writeI32((int) (local2 + 36) < 0 ? (local2 + 36) : (local2 + 36) + 0, (int) arg1); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_7); + } + instance.global(0).setValue(((long) (local2 + 96))); + return local3; + } + + public static long[] call_1097(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1097(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1098(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local2 = (((int) instance.global(0).getValue()) - 192); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 188, (int) 47720); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 184, (int) 588); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) 13034); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) arg0); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local2 + 176)); + callArgs_0[0] = ((long) (arg1 + 368)); + instance.getMachine().call(112, callArgs_0); + label_1: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 188) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 188) : memory.readInt((int) local2 < 0 ? local2 : local2 + 188) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + int ciTableIdx_1 = (int) (local3); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 176)); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 188, (int) 47720); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 184, (int) 588); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) 12348); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) arg0); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 176)); + callArgs_2[0] = ((long) (arg1 + 228)); + instance.getMachine().call(112, callArgs_2); + label_2: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 188) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 188) : memory.readInt((int) local2 < 0 ? local2 : local2 + 188) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + int ciTableIdx_3 = (int) (local3); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 176)); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 188, (int) 47720); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 184, (int) 588); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) 13761); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) arg0); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 176)); + callArgs_4[0] = ((long) (arg1 + 248)); + instance.getMachine().call(112, callArgs_4); + label_3: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 188) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 188) : memory.readInt((int) local2 < 0 ? local2 : local2 + 188) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + int ciTableIdx_5 = (int) (local3); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 176)); + ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 188, (int) 47720); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 184, (int) 588); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) 16363); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) arg0); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (local2 + 176)); + callArgs_6[0] = ((long) (arg1 + 288)); + instance.getMachine().call(112, callArgs_6); + label_4: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 188) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 188) : memory.readInt((int) local2 < 0 ? local2 : local2 + 188) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_4; + } + int ciTableIdx_7 = (int) (local3); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 176)); + ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 188, (int) 47720); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 184, (int) 588); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) arg0); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) (local2 + 176)); + callArgs_8[0] = ((long) (arg1 + 308)); + instance.getMachine().call(112, callArgs_8); + label_5: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 188) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 188) : memory.readInt((int) local2 < 0 ? local2 : local2 + 188) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_5; + } + int ciTableIdx_9 = (int) (local3); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 176)); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 188, (int) 47720); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 184, (int) 588); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) arg0); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) (local2 + 176)); + callArgs_10[0] = ((long) (arg1 + 328)); + instance.getMachine().call(112, callArgs_10); + label_6: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 188) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 188) : memory.readInt((int) local2 < 0 ? local2 : local2 + 188) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_6; + } + int ciTableIdx_11 = (int) (local3); + int ciFuncId_11 = instance.table(0).requiredRef(ciTableIdx_11); + com.dylibso.chicory.runtime.Instance ciRefInstance_11 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_11), instance); + if (!ciRefInstance_11.type(ciRefInstance_11.functionType(ciFuncId_11)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 176)); + ciRefInstance_11.getMachine().call(ciFuncId_11, callArgs_11); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 188, (int) 47720); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 184, (int) 588); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) 14710); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) arg0); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) (local2 + 176)); + callArgs_12[0] = ((long) (arg1 + 208)); + instance.getMachine().call(112, callArgs_12); + label_7: { + local3 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 188) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 188) : memory.readInt((int) local2 < 0 ? local2 : local2 + 188) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_7; + } + int ciTableIdx_13 = (int) (local3); + int ciFuncId_13 = instance.table(0).requiredRef(ciTableIdx_13); + com.dylibso.chicory.runtime.Instance ciRefInstance_13 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_13), instance); + if (!ciRefInstance_13.type(ciRefInstance_13.functionType(ciFuncId_13)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 176)); + ciRefInstance_13.getMachine().call(ciFuncId_13, callArgs_13); + } + label_8: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 76); + local5 = memory.readInt((int) (arg1 + 80) < 0 ? (arg1 + 80) : (arg1 + 80) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local4) != 0) { + break label_8; + } + local6 = (arg0 + 20); + label_9: while (true) { + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) local3); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 12) & 0xFF)) != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0)) != 0) { + break label_10; + } + label_11: { + local7 = (local3 + 16); + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) local7); + callArgs_14[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 288)); + long[] callResult_14 = instance.getMachine().call(116, callArgs_14); + local8 = ((int) callResult_14[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local8) != 0) { + break label_11; + } + local8 = (local3 + 40); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local10 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 51); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 160, (int) 16363); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 164, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local10, 0) != 0 ? local9 : local8)); + long[] callArgs_15 = new long[4]; + callArgs_15[3] = ((long) (local2 + 160)); + callArgs_15[2] = ((long) 30920); + callArgs_15[1] = ((long) local7); + callArgs_15[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_15); + break label_10; + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) local8); + callArgs_16[0] = ((long) local7); + instance.getMachine().call(161, callArgs_16); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 188, (int) 47832); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 184, (int) 589); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) arg0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 176, (int) local3); + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) (local2 + 176)); + callArgs_17[0] = ((long) (local3 + 128)); + instance.getMachine().call(112, callArgs_17); + label_12: { + local7 = memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 188) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 188) : memory.readInt((int) local2 < 0 ? local2 : local2 + 188) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_12; + } + int ciTableIdx_18 = (int) (local7); + int ciFuncId_18 = instance.table(0).requiredRef(ciTableIdx_18); + com.dylibso.chicory.runtime.Instance ciRefInstance_18 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_18), instance); + if (!ciRefInstance_18.type(ciRefInstance_18.functionType(ciFuncId_18)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 176)); + ciRefInstance_18.getMachine().call(ciFuncId_18, callArgs_18); + } + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) local3); + callArgs_19[0] = ((long) local6); + long[] callResult_19 = instance.getMachine().call(454, callArgs_19); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) 0); + local4 = (local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + label_13: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 112); + local7 = memory.readInt((int) (arg1 + 116) < 0 ? (arg1 + 116) : (arg1 + 116) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local3) != 0) { + break label_13; + } + label_14: while (true) { + label_15: { + label_16: { + label_17: { + label_18: { + label_19: { + label_20: { + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + switch(memory.readInt((int) local4 < 0 ? local4 : local4 + 12)) { + case 0: + { + break label_20; + } + case 1: + { + break label_19; + } + case 2: + { + break label_18; + } + case 3: + { + break label_17; + } + case 4: + { + break label_16; + } + default: + { + break label_15; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0)) != 0) { + break label_15; + } + label_21: { + local5 = (local4 + 16); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) local5); + callArgs_20[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 228)); + long[] callResult_20 = instance.getMachine().call(116, callArgs_20); + local6 = ((int) callResult_20[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + break label_21; + } + local6 = (local4 + 40); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local4 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 51); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) 12348); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0 ? local8 : local6)); + long[] callArgs_21 = new long[4]; + callArgs_21[3] = ((long) (local2 + 80)); + callArgs_21[2] = ((long) 30920); + callArgs_21[1] = ((long) local5); + callArgs_21[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_21); + break label_15; + } + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) local6); + callArgs_22[0] = ((long) local5); + instance.getMachine().call(161, callArgs_22); + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0)) != 0) { + break label_15; + } + label_22: { + local5 = (local4 + 16); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) local5); + callArgs_23[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_23 = instance.getMachine().call(116, callArgs_23); + local6 = ((int) callResult_23[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + break label_22; + } + local6 = (local4 + 40); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local4 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 51); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 100, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0 ? local8 : local6)); + long[] callArgs_24 = new long[4]; + callArgs_24[3] = ((long) (local2 + 96)); + callArgs_24[2] = ((long) 30920); + callArgs_24[1] = ((long) local5); + callArgs_24[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_24); + break label_15; + } + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) local6); + callArgs_25[0] = ((long) local5); + instance.getMachine().call(161, callArgs_25); + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0)) != 0) { + break label_15; + } + label_23: { + local5 = (local4 + 16); + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) local5); + callArgs_26[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_26 = instance.getMachine().call(116, callArgs_26); + local6 = ((int) callResult_26[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + break label_23; + } + local6 = (local4 + 40); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local4 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 51); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 112, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 116, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0 ? local8 : local6)); + long[] callArgs_27 = new long[4]; + callArgs_27[3] = ((long) (local2 + 112)); + callArgs_27[2] = ((long) 30920); + callArgs_27[1] = ((long) local5); + callArgs_27[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_27); + break label_15; + } + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) local6); + callArgs_28[0] = ((long) local5); + instance.getMachine().call(161, callArgs_28); + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0)) != 0) { + break label_15; + } + label_24: { + local5 = (local4 + 16); + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) local5); + callArgs_29[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 248)); + long[] callResult_29 = instance.getMachine().call(116, callArgs_29); + local6 = ((int) callResult_29[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + break label_24; + } + local6 = (local4 + 40); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local4 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 51); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 128, (int) 13761); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 132, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0 ? local8 : local6)); + long[] callArgs_30 = new long[4]; + callArgs_30[3] = ((long) (local2 + 128)); + callArgs_30[2] = ((long) 30920); + callArgs_30[1] = ((long) local5); + callArgs_30[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_30); + break label_15; + } + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) local6); + callArgs_31[0] = ((long) local5); + instance.getMachine().call(161, callArgs_31); + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0)) != 0) { + break label_15; + } + label_25: { + local5 = (local4 + 16); + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) local5); + callArgs_32[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 208)); + long[] callResult_32 = instance.getMachine().call(116, callArgs_32); + local6 = ((int) callResult_32[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + break label_25; + } + local6 = (local4 + 40); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local4 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 51); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 144, (int) 14710); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 148, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0 ? local8 : local6)); + long[] callArgs_33 = new long[4]; + callArgs_33[3] = ((long) (local2 + 144)); + callArgs_33[2] = ((long) 30920); + callArgs_33[1] = ((long) local5); + callArgs_33[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_33); + break label_15; + } + long[] callArgs_34 = new long[2]; + callArgs_34[1] = ((long) local6); + callArgs_34[0] = ((long) local5); + instance.getMachine().call(161, callArgs_34); + } + local3 = (local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + } + label_26: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 88); + local4 = memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_26; + } + local7 = (arg0 + 20); + label_27: while (true) { + long[] callArgs_35 = new long[2]; + callArgs_35[1] = ((long) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 24)); + callArgs_35[0] = ((long) local7); + long[] callResult_35 = instance.getMachine().call(453, callArgs_35); + local3 = (local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_27; + } + break; + } + } + label_28: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 64); + local7 = memory.readInt((int) (arg1 + 68) < 0 ? (arg1 + 68) : (arg1 + 68) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local3) != 0) { + break label_28; + } + label_29: while (true) { + label_30: { + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 12) & 0xFF)) != 0) { + break label_30; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0)) != 0) { + break label_30; + } + label_31: { + local5 = (local4 + 16); + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) local5); + callArgs_36[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 288)); + long[] callResult_36 = instance.getMachine().call(116, callArgs_36); + local6 = ((int) callResult_36[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + break label_31; + } + local6 = (local4 + 40); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local4 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 51); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 64, (int) 16363); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 68, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0 ? local8 : local6)); + long[] callArgs_37 = new long[4]; + callArgs_37[3] = ((long) (local2 + 64)); + callArgs_37[2] = ((long) 30920); + callArgs_37[1] = ((long) local5); + callArgs_37[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_37); + break label_30; + } + long[] callArgs_38 = new long[2]; + callArgs_38[1] = ((long) local6); + callArgs_38[0] = ((long) local5); + instance.getMachine().call(161, callArgs_38); + } + local3 = (local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_29; + } + break; + } + } + label_32: { + local8 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 148); + local10 = memory.readInt((int) (arg1 + 152) < 0 ? (arg1 + 152) : (arg1 + 152) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local10, local8) != 0) { + break label_32; + } + local11 = (arg0 + 20); + label_33: while (true) { + label_34: { + local4 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0)) != 0) { + break label_34; + } + label_35: { + local3 = (local4 + 16); + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) local3); + callArgs_39[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_39 = instance.getMachine().call(116, callArgs_39); + local7 = ((int) callResult_39[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local7) != 0) { + break label_35; + } + local7 = (local4 + 40); + local5 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + local6 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 51); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 52, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? local5 : local7)); + long[] callArgs_40 = new long[4]; + callArgs_40[3] = ((long) (local2 + 48)); + callArgs_40[2] = ((long) 30920); + callArgs_40[1] = ((long) local3); + callArgs_40[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_40); + break label_34; + } + long[] callArgs_41 = new long[2]; + callArgs_41[1] = ((long) local7); + callArgs_41[0] = ((long) local3); + instance.getMachine().call(161, callArgs_41); + } + long[] callArgs_42 = new long[2]; + callArgs_42[1] = ((long) (local4 + 60)); + callArgs_42[0] = ((long) local11); + long[] callResult_42 = instance.getMachine().call(453, callArgs_42); + label_36: { + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 72); + local4 = memory.readInt((int) (local4 + 76) < 0 ? (local4 + 76) : (local4 + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_36; + } + label_37: while (true) { + label_38: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)) != 0) { + break label_38; + } + local7 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(36, memory.readInt((int) local7 < 0 ? local7 : local7 + 32)) != 0) { + break label_38; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local7 + 56) < 0 ? (local7 + 56) : (local7 + 56) + 0)) != 0) { + break label_38; + } + label_39: { + local5 = (local7 + 36); + long[] callArgs_43 = new long[2]; + callArgs_43[1] = ((long) local5); + callArgs_43[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 228)); + long[] callResult_43 = instance.getMachine().call(116, callArgs_43); + local6 = ((int) callResult_43[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + break label_39; + } + local6 = (local7 + 60); + local9 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local7 = (int) (byte) memory.read((int) local7 < 0 ? local7 : local7 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) 12348); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0) != 0 ? local9 : local6)); + long[] callArgs_44 = new long[4]; + callArgs_44[3] = ((long) (local2 + 32)); + callArgs_44[2] = ((long) 30920); + callArgs_44[1] = ((long) local5); + callArgs_44[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_44); + break label_38; + } + long[] callArgs_45 = new long[2]; + callArgs_45[1] = ((long) local6); + callArgs_45[0] = ((long) local5); + instance.getMachine().call(161, callArgs_45); + } + local3 = (local3 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_37; + } + break; + } + } + local8 = (local8 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local10, local8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_33; + } + break; + } + } + label_40: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 172); + local7 = memory.readInt((int) (arg1 + 176) < 0 ? (arg1 + 176) : (arg1 + 176) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local3) != 0) { + break label_40; + } + local5 = (arg0 + 20); + label_41: while (true) { + label_42: { + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0)) != 0) { + break label_42; + } + label_43: { + local6 = (local4 + 16); + long[] callArgs_46 = new long[2]; + callArgs_46[1] = ((long) local6); + callArgs_46[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_46 = instance.getMachine().call(116, callArgs_46); + local8 = ((int) callResult_46[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local8) != 0) { + break label_43; + } + local8 = (local4 + 40); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local10 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 51); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local10, 0) != 0 ? local9 : local8)); + long[] callArgs_47 = new long[4]; + callArgs_47[3] = ((long) (local2 + 16)); + callArgs_47[2] = ((long) 30920); + callArgs_47[1] = ((long) local6); + callArgs_47[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_47); + break label_42; + } + long[] callArgs_48 = new long[2]; + callArgs_48[1] = ((long) local8); + callArgs_48[0] = ((long) local6); + instance.getMachine().call(161, callArgs_48); + } + long[] callArgs_49 = new long[2]; + callArgs_49[1] = ((long) (local4 + 52)); + callArgs_49[0] = ((long) local5); + long[] callResult_49 = instance.getMachine().call(453, callArgs_49); + local3 = (local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_41; + } + break; + } + } + label_44: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 184); + local7 = memory.readInt((int) (arg1 + 188) < 0 ? (arg1 + 188) : (arg1 + 188) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local3) != 0) { + break label_44; + } + label_45: while (true) { + label_46: { + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) local4 < 0 ? local4 : local4 + 20)) != 0) { + break label_46; + } + label_47: { + long[] callArgs_50 = new long[2]; + callArgs_50[1] = ((long) local4); + callArgs_50[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 228)); + long[] callResult_50 = instance.getMachine().call(116, callArgs_50); + local5 = ((int) callResult_50[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local5) != 0) { + break label_47; + } + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + local6 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 35); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 12348); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? local5 : (local4 + 24))); + long[] callArgs_51 = new long[4]; + callArgs_51[3] = ((long) local2); + callArgs_51[2] = ((long) 30920); + callArgs_51[1] = ((long) local4); + callArgs_51[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_51); + break label_46; + } + long[] callArgs_52 = new long[2]; + callArgs_52[1] = ((long) local5); + callArgs_52[0] = ((long) local4); + instance.getMachine().call(161, callArgs_52); + } + local3 = (local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_45; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) 0); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84); + instance.global(0).setValue(((long) (local2 + 192))); + return local3; + } + + public static long[] call_1098(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1098(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1099(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = memory.readInt((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0); + local5 = memory.readInt((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local8 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0) != 0 ? local7 : arg1)); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local3); + callArgs_0[2] = ((long) 30840); + callArgs_0[1] = ((long) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local5, local4) != 0 ? arg1 : arg2) + 12)); + callArgs_0[0] = ((long) local6); + instance.getMachine().call(1100, callArgs_0); + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_1099(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1099(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_1100(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 84, (int) 1); + local5 = local4; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 148, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 144, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) (local5 + 16)); + local6 = (local5 + 16); + label_1: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) 128); + callArgs_0[0] = ((long) (local5 + 16)); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg3 = (((int) callResult_0[0]) + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, 129) != 0) { + break label_1; + } + local6 = (local4 - ((arg3 + 15) & -16)); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local6); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 144)); + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg3); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1875, callArgs_1); + } + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) 1); + label_2: { + label_3: { + label_4: { + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)) != 0) { + break label_4; + } + arg2 = ((local5 + 152) + 16); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + local4 = ((local5 + 152) + 8); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 152, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) 1); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 4, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 152)); + memory.writeLong((int) (arg3 + 12) < 0 ? (arg3 + 12) : (arg3 + 12) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (arg3 + 20) < 0 ? (arg3 + 20) : (arg3 + 20) + 0, (int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 2147483632) != 0) { + break label_2; + } + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 10) != 0) { + break label_6; + } + arg2 = (arg3 + 24); + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 35, (byte) (arg1)); + break label_5; + } + local4 = ((arg1 | 15) + 1); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local4); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg2 = ((int) callResult_3[0]); + memory.writeI32((int) (arg3 + 32) < 0 ? (arg3 + 32) : (arg3 + 32) + 0, (int) (local4 | -2147483648)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 24, (int) arg2); + memory.writeI32((int) (arg3 + 28) < 0 ? (arg3 + 28) : (arg3 + 28) + 0, (int) arg1); + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg1); + callArgs_4[1] = ((long) local6); + callArgs_4[0] = ((long) arg2); + long[] callResult_4 = instance.getMachine().call(1891, callArgs_4); + memory.writeByte((int) (((int) callResult_4[0]) + arg1) < 0 ? (((int) callResult_4[0]) + arg1) : (((int) callResult_4[0]) + arg1) + 0, (byte) (0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg3 + 36)); + break label_3; + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local5 + 12)); + callArgs_5[2] = ((long) arg1); + callArgs_5[1] = ((long) (local5 + 8)); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(459, callArgs_5); + } + instance.global(0).setValue(((long) (local5 + 176))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1100(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1100(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1101(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = memory.readInt((int) (arg0 + 4) < 0 ? (arg0 + 4) : (arg0 + 4) + 0); + local5 = memory.readInt((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0); + local6 = memory.readInt((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0); + local7 = memory.readInt((int) (arg1 + 32) < 0 ? (arg1 + 32) : (arg1 + 32) + 0); + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local8 = memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0); + arg0 = memory.readInt((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), 0) != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : arg1)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, ((local8 - arg0) >> 3)) != 0 ? 11553 : 13630)); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local3); + callArgs_0[2] = ((long) 30840); + callArgs_0[1] = ((long) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local6, local5) != 0 ? arg1 : arg2) + 12)); + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1100, callArgs_0); + instance.global(0).setValue(((long) (local3 + 16))); + return; + } + + public static long[] call_1101(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1101(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1102(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 47372); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 72); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + local2 = (local3 + -12); + label_3: while (true) { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + 11) < 0 ? (local2 + 11) : (local2 + 11) + 0), -1) != 0) { + break label_4; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local2); + local2 = (local2 + -12); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 72); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) local1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + } + label_5: { + local2 = memory.readInt((int) (arg0 + 60) < 0 ? (arg0 + 60) : (arg0 + 60) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_5; + } + memory.writeI32((int) (arg0 + 64) < 0 ? (arg0 + 64) : (arg0 + 64) + 0, (int) local2); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + } + label_6: { + local2 = memory.readInt((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_6; + } + memory.writeI32((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0, (int) local2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + } + label_7: { + local2 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_7; + } + memory.writeI32((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (int) local2); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_4); + } + label_8: { + local2 = memory.readInt((int) (arg0 + 24) < 0 ? (arg0 + 24) : (arg0 + 24) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_8; + } + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) local2); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_5); + } + return arg0; + } + + public static long[] call_1102(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1102(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1103(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1102, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) ((int) callResult_0[0])); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1103(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1103(arg0, memory, instance); + return null; + } + + public static int func_1104(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 36); + label_1: { + label_2: { + local4 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0), local4) != 0) { + break label_2; + } + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 47), 0) != 0) { + break label_4; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + break label_3; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0)); + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1647, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) (local4 + 12)); + break label_1; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) (arg0 + 72)); + instance.getMachine().call(1105, callArgs_1); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (arg1 + 48) < 0 ? (arg1 + 48) : (arg1 + 48) + 0) & 0xFF)) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 72) < 0 ? (arg1 + 72) : (arg1 + 72) + 0)) != 0) { + break label_5; + } + label_6: { + local4 = (arg1 + 52); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 288)); + long[] callResult_2 = instance.getMachine().call(116, callArgs_2); + local3 = ((int) callResult_2[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local3) != 0) { + break label_6; + } + local3 = (arg1 + 76); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 87); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 16363); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local3)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local2); + callArgs_3[2] = ((long) 30920); + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_3); + break label_5; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) local4); + instance.getMachine().call(161, callArgs_4); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1104(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1104(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1105(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 12); + local5 = (local4 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 357913942) != 0) { + break label_4; + } + local6 = 0; + label_5: { + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local3), 12); + local8 = (local7 << 1); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local5) != 0 ? local8 : local5) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 357913942) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local5 * 12)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local6 = ((int) callResult_0[0]); + } + local7 = (local5 * 12); + local5 = (local6 + (local4 * 12)); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), 0) != 0) { + break label_7; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_6; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_1[0] = ((long) local5); + instance.getMachine().call(1647, callArgs_1); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + local6 = (local6 + local7); + local4 = (local5 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_2; + } + label_8: while (true) { + local5 = (local5 + -12); + local2 = (local2 + -12); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + arg1 = (local2 + 8); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_1; + } + local2 = (local2 + -12); + label_9: while (true) { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + 11) < 0 ? (local2 + 11) : (local2 + 11) + 0), -1) != 0) { + break label_10; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_2); + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2); + local2 = (local2 + -12); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_11; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_5); + } + return; + } + + public static long[] call_1105(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1105(arg0, arg1, memory, instance); + return null; + } + + public static int func_1106(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + local3 = (local2 + -12); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + -1) < 0 ? (local2 + -1) : (local2 + -1) + 0), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) local3); + return 0; + } + + public static long[] call_1106(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1106(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1107(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1108, callArgs_0); + return 0; + } + + public static long[] call_1107(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1107(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1108(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 20)) != 0) { + break label_1; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 72); + local4 = (memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0) - local3); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S(local4, 12); + local6 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 35) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 1) != 0) { + break label_3; + } + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0); + local9 = (local8 != 0 ? memory.readInt((int) (arg1 + 28) < 0 ? (arg1 + 28) : (arg1 + 28) + 0) : local6); + local10 = (arg1 + 24); + local11 = local5; + label_4: while (true) { + label_5: { + local12 = local11; + local11 = (local12 + -1); + local4 = (local3 + (local11 * 12)); + local13 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 11) & 0xFF); + local14 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local13); + local15 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local14, 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, (local15 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 4) : local13)) != 0) { + break label_5; + } + local6 = (local8 != 0 ? memory.readInt((int) local10 < 0 ? local10 : local10 + 0) : local10); + label_6: { + if (local15 != 0) { + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local14) != 0) { + break label_2; + } + label_7: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF), ((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_5; + } + local6 = (local6 + 1); + local4 = (local4 + 1); + local13 = (local13 + -1); + if (local13 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break label_2; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_2; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local9); + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) (local15 != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : local4)); + long[] callResult_0 = instance.getMachine().call(1889, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_0[0])) != 0) { + break label_2; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local12, 1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0) != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24) : (arg1 + 24))); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30947); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local5 - local12)); + callArgs_2[0] = ((long) arg1); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return; + } + + public static long[] call_1108(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1108(arg0, arg1, memory, instance); + return null; + } + + public static int func_1109(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1108, callArgs_0); + return 0; + } + + public static long[] call_1109(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1109(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1110(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + label_1: { + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36); + local3 = memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_1; + } + label_2: while (true) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1108, callArgs_0); + local2 = (local2 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 48)); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1108, callArgs_1); + return 0; + } + + public static long[] call_1110(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1110(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1111(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 184); + local4 = memory.readInt((int) (arg1 + 188) < 0 ? (arg1 + 188) : (arg1 + 188) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_1; + } + local5 = (local3 + 92); + label_2: while (true) { + label_3: { + local3 = local5; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(2, (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) & -2)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (local3 + -52) < 0 ? (local3 + -52) : (local3 + -52) + 0)) != 0) { + break label_3; + } + label_4: { + local5 = (local3 + -72); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 208)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local6 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + break label_4; + } + local6 = (local3 + -48); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local8 = (int) (byte) memory.read((int) (local3 + -37) < 0 ? (local3 + -37) : (local3 + -37) + 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 14710); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0) != 0 ? local7 : local6)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local2 + 16)); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_3; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local6); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(161, callArgs_2); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local3 + -36)); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1108, callArgs_3); + local5 = (local3 + 96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, (local3 + 4)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + local5 = (arg1 + 36); + label_5: { + label_6: { + local3 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0), local3) != 0) { + break label_6; + } + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 47), 0) != 0) { + break label_8; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + break label_7; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0)); + callArgs_4[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_4[0] = ((long) local3); + instance.getMachine().call(1647, callArgs_4); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) (local3 + 12)); + break label_5; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local5); + callArgs_5[0] = ((long) (arg0 + 72)); + instance.getMachine().call(1105, callArgs_5); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (arg1 + 48) < 0 ? (arg1 + 48) : (arg1 + 48) + 0) & 0xFF)) != 0) { + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 72) < 0 ? (arg1 + 72) : (arg1 + 72) + 0)) != 0) { + break label_9; + } + label_10: { + local3 = (arg1 + 52); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local3); + callArgs_6[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 288)); + long[] callResult_6 = instance.getMachine().call(116, callArgs_6); + local5 = ((int) callResult_6[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local5) != 0) { + break label_10; + } + local5 = (arg1 + 76); + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local6 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 87); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 16363); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? local4 : local5)); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) local2); + callArgs_7[2] = ((long) 30920); + callArgs_7[1] = ((long) local3); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_7); + break label_9; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local5); + callArgs_8[0] = ((long) local3); + instance.getMachine().call(161, callArgs_8); + } + instance.global(0).setValue(((long) (local2 + 32))); + return 0; + } + + public static long[] call_1111(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1111(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1112(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + local3 = (local2 + -12); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + -1) < 0 ? (local2 + -1) : (local2 + -1) + 0), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) local3); + return 0; + } + + public static long[] call_1112(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1112(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1113(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 228)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 12348); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1113(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1113(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1114(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 36) & 0xFF)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 60) < 0 ? (arg1 + 60) : (arg1 + 60) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 40); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 288)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 64); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 75); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 16363); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local2 + 16)); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 160) < 0 ? (arg1 + 160) : (arg1 + 160) + 0)) != 0) { + break label_3; + } + label_4: { + local3 = (arg1 + 140); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local3); + callArgs_3[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_3 = instance.getMachine().call(116, callArgs_3); + local4 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_4; + } + local4 = (arg1 + 164); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 175); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local2); + callArgs_4[2] = ((long) 30920); + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_4); + break label_3; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(161, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 32))); + return 0; + } + + public static long[] call_1114(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1114(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1115(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 248)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 13761); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1115(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1115(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1116(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 248)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 13761); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1116(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1116(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1117(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 36); + label_1: { + label_2: { + local4 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0), local4) != 0) { + break label_2; + } + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 47), 0) != 0) { + break label_4; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + break label_3; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0)); + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1647, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) (local4 + 12)); + break label_1; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) (arg0 + 72)); + instance.getMachine().call(1105, callArgs_1); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (arg1 + 48) < 0 ? (arg1 + 48) : (arg1 + 48) + 0) & 0xFF)) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 72) < 0 ? (arg1 + 72) : (arg1 + 72) + 0)) != 0) { + break label_5; + } + label_6: { + local4 = (arg1 + 52); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 288)); + long[] callResult_2 = instance.getMachine().call(116, callArgs_2); + local3 = ((int) callResult_2[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local3) != 0) { + break label_6; + } + local3 = (arg1 + 76); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 87); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 16363); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local3)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local2); + callArgs_3[2] = ((long) 30920); + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_3); + break label_5; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) local4); + instance.getMachine().call(161, callArgs_4); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1117(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1117(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1118(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + local3 = (local2 + -12); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + -1) < 0 ? (local2 + -1) : (local2 + -1) + 0), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) local3); + return 0; + } + + public static long[] call_1118(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1118(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1119(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1119(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1119(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1120(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + label_2: { + local4 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(131, callArgs_0); + local3 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local3) != 0) { + break label_2; + } + local3 = (arg1 + 60); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : local3)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30977); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1120(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1120(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1121(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + label_2: { + local4 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(131, callArgs_0); + local3 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local3) != 0) { + break label_2; + } + local3 = (arg1 + 60); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : local3)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30977); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1121(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1121(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1122(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + label_2: { + local4 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(131, callArgs_0); + local3 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local3) != 0) { + break label_2; + } + local3 = (arg1 + 60); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : local3)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30977); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) local4); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1122(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1122(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1123(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 36); + label_1: { + label_2: { + local4 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0), local4) != 0) { + break label_2; + } + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 47), 0) != 0) { + break label_4; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + break label_3; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0)); + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 36)); + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1647, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) (local4 + 12)); + break label_1; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) (arg0 + 72)); + instance.getMachine().call(1105, callArgs_1); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (arg1 + 48) < 0 ? (arg1 + 48) : (arg1 + 48) + 0) & 0xFF)) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 72) < 0 ? (arg1 + 72) : (arg1 + 72) + 0)) != 0) { + break label_5; + } + label_6: { + local4 = (arg1 + 52); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 288)); + long[] callResult_2 = instance.getMachine().call(116, callArgs_2); + local3 = ((int) callResult_2[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local3) != 0) { + break label_6; + } + local3 = (arg1 + 76); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 87); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 16363); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local3)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local2); + callArgs_3[2] = ((long) 30920); + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_3); + break label_5; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) local4); + instance.getMachine().call(161, callArgs_4); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1123(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1123(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1124(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + local3 = (local2 + -12); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + -1) < 0 ? (local2 + -1) : (local2 + -1) + 0), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) local3); + return 0; + } + + public static long[] call_1124(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1124(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1125(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local2 + 16)); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0)) != 0) { + break label_3; + } + label_4: { + local3 = (arg1 + 72); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local3); + callArgs_3[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_3 = instance.getMachine().call(116, callArgs_3); + local4 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_4; + } + local4 = (arg1 + 96); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 107); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local2); + callArgs_4[2] = ((long) 30920); + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_4); + break label_3; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(161, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 32))); + return 0; + } + + public static long[] call_1125(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1125(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1126(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 348)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 7034); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1126(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1126(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1127(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1127(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1127(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1128(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1128(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1128(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1129(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 72); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 348)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 96); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 107); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 7034); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local2 + 16)); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_3; + } + label_4: { + local3 = (arg1 + 36); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local3); + callArgs_3[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_3 = instance.getMachine().call(116, callArgs_3); + local4 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_4; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local2); + callArgs_4[2] = ((long) 30920); + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_4); + break label_3; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(161, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 32))); + return 0; + } + + public static long[] call_1129(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1129(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1130(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1130(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1130(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1131(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local2 + 16)); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0)) != 0) { + break label_3; + } + label_4: { + local3 = (arg1 + 72); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local3); + callArgs_3[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_3 = instance.getMachine().call(116, callArgs_3); + local4 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_4; + } + local4 = (arg1 + 96); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 107); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local2); + callArgs_4[2] = ((long) 30920); + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_4); + break label_3; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(161, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 32))); + return 0; + } + + public static long[] call_1131(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1131(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1132(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 368)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 7014); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1132(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1132(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1133(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 368)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 7014); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local2 + 16)); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0)) != 0) { + break label_3; + } + label_4: { + local3 = (arg1 + 72); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local3); + callArgs_3[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_3 = instance.getMachine().call(116, callArgs_3); + local4 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_4; + } + local4 = (arg1 + 96); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 107); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local2); + callArgs_4[2] = ((long) 30920); + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_4); + break label_3; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(161, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 32))); + return 0; + } + + public static long[] call_1133(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1133(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1134(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1134(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1134(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1135(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1135(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1135(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1136(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1136(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1136(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1137(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1137(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1137(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1138(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1138(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1138(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1139(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 228)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 12348); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1139(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1139(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1140(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 228)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 12348); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1140(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1140(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1141(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 36) & 0xFF)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 60) < 0 ? (arg1 + 60) : (arg1 + 60) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 40); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 288)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 64); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 75); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 16363); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local2 + 16)); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 160) < 0 ? (arg1 + 160) : (arg1 + 160) + 0)) != 0) { + break label_3; + } + label_4: { + local3 = (arg1 + 140); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local3); + callArgs_3[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 308)); + long[] callResult_3 = instance.getMachine().call(116, callArgs_3); + local4 = ((int) callResult_3[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_4; + } + local4 = (arg1 + 164); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 175); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 17326); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local2); + callArgs_4[2] = ((long) 30920); + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_4); + break label_3; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) local3); + instance.getMachine().call(161, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 32))); + return 0; + } + + public static long[] call_1141(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1141(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1142(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1142(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1142(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1143(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = (arg1 + 40); + label_1: { + label_2: { + local4 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0), local4) != 0) { + break label_2; + } + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 51), 0) != 0) { + break label_4; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + break label_3; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0)); + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 40)); + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1647, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) (local4 + 12)); + break label_1; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) (arg0 + 72)); + instance.getMachine().call(1105, callArgs_1); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (arg1 + 52) < 0 ? (arg1 + 52) : (arg1 + 52) + 0) & 0xFF)) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 76) < 0 ? (arg1 + 76) : (arg1 + 76) + 0)) != 0) { + break label_5; + } + label_6: { + local4 = (arg1 + 56); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 288)); + long[] callResult_2 = instance.getMachine().call(116, callArgs_2); + local3 = ((int) callResult_2[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local3) != 0) { + break label_6; + } + local3 = (arg1 + 80); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 91); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 16363); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local3)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local2); + callArgs_3[2] = ((long) 30920); + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_3); + break label_5; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) local4); + instance.getMachine().call(161, callArgs_4); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1143(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1143(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1144(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = (arg2 + 44); + label_1: { + label_2: { + local5 = memory.readInt((int) (arg2 + 40) < 0 ? (arg2 + 40) : (arg2 + 40) + 0); + if (local5 != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, memory.readInt((int) local4 < 0 ? local4 : local4 + 0)) != 0) { + break label_1; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local5) != 0) { + break label_1; + } + label_3: { + local5 = (arg2 + 20); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 208)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local6 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local6) != 0) { + break label_3; + } + local6 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 44); + arg2 = (int) (byte) memory.read((int) arg2 < 0 ? arg2 : arg2 + 55); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 14710); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg2, 0) != 0 ? local6 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local3); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local6); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local3 + 16))); + return 0; + } + + public static long[] call_1144(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1144(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1145(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + local3 = (local2 + -12); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + -1) < 0 ? (local2 + -1) : (local2 + -1) + 0), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) local3); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 200)); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1108, callArgs_1); + return 0; + } + + public static long[] call_1145(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1145(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1146(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = memory.readInt((int) (arg0 + 76) < 0 ? (arg0 + 76) : (arg0 + 76) + 0); + local3 = (local2 + -12); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + -1) < 0 ? (local2 + -1) : (local2 + -1) + 0), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 76, (int) local3); + return 0; + } + + public static long[] call_1146(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1146(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1147(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 208)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 14710); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1147(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1147(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1148(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 36)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1108, callArgs_0); + return 0; + } + + public static long[] call_1148(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1148(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1149(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1149(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1149(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1150(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0)) != 0) { + break label_1; + } + label_2: { + local3 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 328)); + long[] callResult_0 = instance.getMachine().call(116, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local4) != 0) { + break label_2; + } + local4 = (arg1 + 60); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + arg1 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 71); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 1196); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 0) != 0 ? local5 : local4)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local2); + callArgs_1[2] = ((long) 30920); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1100, callArgs_1); + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(161, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + + public static long[] call_1150(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1150(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1151(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 176); + instance.global(0).setValue(((long) local4)); + local5 = local4; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 148, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 144, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) (local5 + 16)); + local6 = (local5 + 16); + label_1: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) 128); + callArgs_0[0] = ((long) (local5 + 16)); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg3 = (((int) callResult_0[0]) + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, 129) != 0) { + break label_1; + } + local6 = (local4 - ((arg3 + 15) & -16)); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local6); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 144)); + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg3); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1875, callArgs_1); + } + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) 1); + label_2: { + label_3: { + label_4: { + arg3 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg3, memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 8)) != 0) { + break label_4; + } + local4 = ((local5 + 152) + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + arg0 = ((local5 + 152) + 8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 152, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(1897, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) 1); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 4, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 152)); + memory.writeLong((int) (arg3 + 12) < 0 ? (arg3 + 12) : (arg3 + 12) + 0, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeI32((int) (arg3 + 20) < 0 ? (arg3 + 20) : (arg3 + 20) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 2147483632) != 0) { + break label_2; + } + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 10) != 0) { + break label_6; + } + local4 = (arg3 + 24); + memory.writeByte((int) arg3 < 0 ? arg3 : arg3 + 35, (byte) (arg1)); + break label_5; + } + arg0 = ((arg1 | 15) + 1); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local4 = ((int) callResult_3[0]); + memory.writeI32((int) (arg3 + 32) < 0 ? (arg3 + 32) : (arg3 + 32) + 0, (int) (arg0 | -2147483648)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 24, (int) local4); + memory.writeI32((int) (arg3 + 28) < 0 ? (arg3 + 28) : (arg3 + 28) + 0, (int) arg1); + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) arg1); + callArgs_4[1] = ((long) local6); + callArgs_4[0] = ((long) local4); + long[] callResult_4 = instance.getMachine().call(1891, callArgs_4); + memory.writeByte((int) (((int) callResult_4[0]) + arg1) < 0 ? (((int) callResult_4[0]) + arg1) : (((int) callResult_4[0]) + arg1) + 0, (byte) (0)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) (arg3 + 36)); + break label_3; + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local5 + 12)); + callArgs_5[2] = ((long) arg1); + callArgs_5[1] = ((long) (local5 + 8)); + callArgs_5[0] = ((long) arg2); + instance.getMachine().call(569, callArgs_5); + } + instance.global(0).setValue(((long) (local5 + 176))); + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1151(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1151(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1152(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1152(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_1152(memory, instance); + return null; + } + + public static void func_1153(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = (arg1 + 16); + local4 = ((int) memory.read((int) (arg1 + 96) < 0 ? (arg1 + 96) : (arg1 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) (local2 + 8)); + instance.getMachine().call(557, callArgs_0); + local4 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 96) & 0xFF); + local5 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 8) + 24) < 0 ? ((local2 + 8) + 24) : ((local2 + 8) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 8) + 32) < 0 ? ((local2 + 8) + 32) : ((local2 + 8) + 32) + 0)); + label_2: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_2; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_1; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 96, (byte) (local4)); + } + label_3: { + arg1 = (local3 + (local4 * 40)); + if (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 36) & 0xFF) != 0) { + break label_3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + + public static long[] call_1153(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1153(arg0, arg1, memory, instance); + return null; + } + + public static int func_1154(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + int block_1_result_0 = 0; + int block_16_result_0 = 0; + local2 = (((int) instance.global(0).getValue()) - 240); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 16); + label_1: while (true) { + label_2: { + label_3: { + label_4: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF)) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((((int) memory.read((int) (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)) < 0 ? (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)) : (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)) + 36) & 0xFF) != 0 ? 2 : 1), arg1) != 0) { + break label_3; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_0[0] = ((long) (local2 + 200)); + instance.getMachine().call(557, callArgs_0); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(132, memory.readInt((int) local2 < 0 ? local2 : local2 + 220)) != 0) { + break label_5; + } + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local4 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) * 40)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 200)); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) ((local2 + 200) + 8) < 0 ? ((local2 + 200) + 8) : ((local2 + 200) + 8) + 0)); + memory.writeLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (long) memory.readLong((int) ((local2 + 200) + 16) < 0 ? ((local2 + 200) + 16) : ((local2 + 200) + 16) + 0)); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) memory.readLong((int) ((local2 + 200) + 24) < 0 ? ((local2 + 200) + 24) : ((local2 + 200) + 24) + 0)); + memory.writeI32((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (int) memory.readInt((int) ((local2 + 200) + 32) < 0 ? ((local2 + 200) + 32) : ((local2 + 200) + 32) + 0)); + label_6: { + if (((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF) != 0) { + break label_6; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local5 * 40)) < 0 ? (local3 + (local5 * 40)) : (local3 + (local5 * 40)) + 36) & 0xFF) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + label_7: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (((int) memory.read((int) local4 < 0 ? local4 : local4 + 11) & 0xFF) != 0) { + break label_7; + } + local4 = ((local2 + 176) + 16); + local5 = ((local2 + 200) + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + local6 = ((local2 + 176) + 8); + local7 = ((local2 + 200) + 8); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 176, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 200)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 + 200)); + callArgs_1[0] = ((long) (local2 + 96)); + instance.getMachine().call(544, callArgs_1); + memory.writeLong((int) ((local2 + 48) + 8) < 0 ? ((local2 + 48) + 8) : ((local2 + 48) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) ((local2 + 48) + 16) < 0 ? ((local2 + 48) + 16) : ((local2 + 48) + 16) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 176)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 107), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 96) : (local2 + 96))); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local2 + 32)); + callArgs_2[2] = ((long) 11148); + callArgs_2[1] = ((long) (local2 + 48)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_2); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 107), -1) != 0) { + break label_8; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 96)); + instance.getMachine().call(1777, callArgs_3); + } + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 200)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) (local2 + 8)); + callArgs_4[0] = ((long) (local2 + 136)); + long[] callResult_4 = instance.getMachine().call(539, callArgs_4); + local5 = ((int) callResult_4[0]); + local6 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local4 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) * 40)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + memory.writeLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (long) memory.readLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) memory.readLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0)); + memory.writeI32((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (int) memory.readInt((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0)); + label_9: { + if (((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF) != 0) { + break label_9; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local6 * 40)) < 0 ? (local3 + (local6 * 40)) : (local3 + (local6 * 40)) + 36) & 0xFF) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local6 ^ 1))); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 12) & 0xFF)) != 0) { + break label_11; + } + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 228); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 14) != 0) { + break label_11; + } + local7 = memory.readInt((int) local2 < 0 ? local2 : local2 + 224); + local6 = (local7 + local4); + local5 = local7; + label_12: while (true) { + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local4 + -13)); + callArgs_5[1] = ((long) 109); + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(1888, callArgs_5); + local4 = ((int) callResult_5[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_11; + } + label_13: { + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 14); + callArgs_6[1] = ((long) 29082); + callArgs_6[0] = ((long) local4); + long[] callResult_6 = instance.getMachine().call(1889, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_6[0])) != 0) { + break label_13; + } + local5 = (local4 + 1); + local4 = (local6 - local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(local4, 14) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break label_11; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local7) != 0) { + break label_10; + } + } + local8 = memory.readLong((int) local2 < 0 ? local2 : local2 + 224); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(25769803776L, (local8 & -4294967296L)) != 0) { + break label_2; + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 6); + callArgs_7[1] = ((long) 13015); + callArgs_7[0] = ((long) (int) local8); + long[] callResult_7 = instance.getMachine().call(1889, callArgs_7); + if (((int) callResult_7[0]) != 0) { + break label_2; + } + } + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local4 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) * 40)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 200)); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) ((local2 + 200) + 8) < 0 ? ((local2 + 200) + 8) : ((local2 + 200) + 8) + 0)); + memory.writeLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (long) memory.readLong((int) ((local2 + 200) + 16) < 0 ? ((local2 + 200) + 16) : ((local2 + 200) + 16) + 0)); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) memory.readLong((int) ((local2 + 200) + 24) < 0 ? ((local2 + 200) + 24) : ((local2 + 200) + 24) + 0)); + memory.writeI32((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (int) memory.readInt((int) ((local2 + 200) + 32) < 0 ? ((local2 + 200) + 32) : ((local2 + 200) + 32) + 0)); + label_14: { + if (((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF) != 0) { + break label_14; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local5 * 40)) < 0 ? (local3 + (local5 * 40)) : (local3 + (local5 * 40)) + 36) & 0xFF) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + label_15: { + local4 = (local3 + ((local4 ^ com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, arg1)) * 40)); + if (((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF) != 0) { + break label_15; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 20); + instance.global(0).setValue(((long) (local2 + 240))); + return local4; + } + local4 = 1; + label_16: while (true) { + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_9[0] = ((long) (local2 + 96)); + instance.getMachine().call(557, callArgs_9); + local6 = ((local2 + 200) + 16); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) ((local2 + 96) + 16) < 0 ? ((local2 + 96) + 16) : ((local2 + 96) + 16) + 0)); + memory.writeI32((int) ((local2 + 200) + 32) < 0 ? ((local2 + 200) + 32) : ((local2 + 200) + 32) + 0, (int) memory.readInt((int) ((local2 + 96) + 32) < 0 ? ((local2 + 96) + 32) : ((local2 + 96) + 32) + 0)); + memory.writeLong((int) ((local2 + 200) + 24) < 0 ? ((local2 + 200) + 24) : ((local2 + 200) + 24) + 0, (long) memory.readLong((int) ((local2 + 96) + 24) < 0 ? ((local2 + 96) + 24) : ((local2 + 96) + 24) + 0)); + local7 = ((local2 + 200) + 8); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) ((local2 + 96) + 8) < 0 ? ((local2 + 96) + 8) : ((local2 + 96) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 200, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 96)); + label_17: { + label_18: { + label_19: { + label_20: { + label_21: { + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 220); + switch((local5 + -19)) { + case 0: + { + break label_19; + } + case 1: + { + break label_17; + } + case 2: + { + break label_17; + } + case 3: + { + break label_17; + } + case 4: + { + break label_17; + } + case 5: + { + break label_17; + } + case 6: + { + break label_17; + } + case 7: + { + break label_17; + } + case 8: + { + break label_17; + } + case 9: + { + break label_17; + } + case 10: + { + break label_17; + } + case 11: + { + break label_20; + } + case 12: + { + break label_17; + } + case 13: + { + break label_17; + } + case 14: + { + break label_17; + } + case 15: + { + break label_17; + } + case 16: + { + break label_17; + } + case 17: + { + break label_17; + } + case 18: + { + break label_17; + } + case 19: + { + break label_17; + } + case 20: + { + break label_17; + } + case 21: + { + break label_17; + } + case 22: + { + break label_17; + } + case 23: + { + break label_17; + } + case 24: + { + break label_17; + } + case 25: + { + break label_18; + } + default: + { + break label_21; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(132, local5) != 0) { + break label_17; + } + } + local4 = (local4 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + memory.writeI32((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 200)); + long[] callArgs_10 = new long[4]; + callArgs_10[3] = ((long) 0); + callArgs_10[2] = ((long) 12668); + callArgs_10[1] = ((long) (local2 + 72)); + callArgs_10[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_10); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + local4 = (local4 + -1); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + } + } + + public static long[] call_1154(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1154(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1155(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = 0; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_1; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, ((int) callResult_1[0])); + } + return local2; + } + + public static long[] call_1155(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1155(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1156(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = 1; + label_1: { + label_2: { + switch((arg0 + -60)) { + case 0: + { + break label_1; + } + case 1: + { + break label_1; + } + case 2: + { + break label_1; + } + case 3: + { + break label_1; + } + case 4: + { + break label_1; + } + case 5: + { + break label_1; + } + case 6: + { + break label_1; + } + case 7: + { + break label_1; + } + case 8: + { + break label_2; + } + case 9: + { + break label_1; + } + case 10: + { + break label_1; + } + case 11: + { + break label_1; + } + case 12: + { + break label_2; + } + case 13: + { + break label_1; + } + case 14: + { + break label_1; + } + case 15: + { + break label_1; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_2; + } + case 19: + { + break label_2; + } + case 20: + { + break label_1; + } + case 21: + { + break label_1; + } + case 22: + { + break label_1; + } + case 23: + { + break label_1; + } + case 24: + { + break label_1; + } + case 25: + { + break label_1; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_1; + } + case 29: + { + break label_1; + } + case 30: + { + break label_2; + } + case 31: + { + break label_1; + } + case 32: + { + break label_1; + } + case 33: + { + break label_1; + } + case 34: + { + break label_1; + } + case 35: + { + break label_2; + } + case 36: + { + break label_1; + } + case 37: + { + break label_1; + } + case 38: + { + break label_1; + } + case 39: + { + break label_1; + } + case 40: + { + break label_1; + } + case 41: + { + break label_1; + } + case 42: + { + break label_2; + } + case 43: + { + break label_1; + } + case 44: + { + break label_1; + } + case 45: + { + break label_1; + } + case 46: + { + break label_1; + } + case 47: + { + break label_1; + } + case 48: + { + break label_1; + } + case 49: + { + break label_1; + } + case 50: + { + break label_1; + } + case 51: + { + break label_1; + } + case 52: + { + break label_2; + } + case 53: + { + break label_1; + } + case 54: + { + break label_1; + } + case 55: + { + break label_1; + } + case 56: + { + break label_1; + } + case 57: + { + break label_1; + } + case 58: + { + break label_1; + } + case 59: + { + break label_1; + } + case 60: + { + break label_1; + } + case 61: + { + break label_1; + } + case 62: + { + break label_1; + } + case 63: + { + break label_1; + } + case 64: + { + break label_1; + } + case 65: + { + break label_1; + } + case 66: + { + break label_1; + } + case 67: + { + break label_2; + } + case 68: + { + break label_2; + } + case 69: + { + break label_1; + } + case 70: + { + break label_1; + } + default: + { + break label_2; + } + } + } + local1 = 0; + } + return local1; + } + + public static long[] call_1156(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1156(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1157(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_1; + } + local1 = 1; + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1156, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + local1 = 0; + arg0 = (arg0 + -68); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 60) != 0) { + break label_1; + } + local1 = ((int) (1729382257048682497L >>> com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg0)) & 1); + } + return local1; + } + + public static long[] call_1157(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1157(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1158(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + local2 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local2) != 0) { + break label_2; + } + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = ((arg0 + (local3 * 40)) + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local2); + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1158(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1158(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1159(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = 0; + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_2; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, ((int) callResult_1[0])) != 0) { + break label_2; + } + local3 = (arg0 + 16); + arg1 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local2 = (local3 + (arg1 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local2 < 0 ? local2 : local2 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local2 + 36) < 0 ? (local2 + 36) : (local2 + 36) + 0, (byte) (0)); + local2 = 1; + local4 = (arg1 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + local3 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (arg1)); + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + } + return local2; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1159(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1159(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1160(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + label_4: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, ((int) callResult_0[0])) != 0) { + break label_4; + } + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + arg1 = ((arg0 + (local3 * 40)) + 52); + if (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF) != 0) { + break label_3; + } + break label_1; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local3 = ((arg0 + 16) + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + local5 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + memory.writeI32((int) ((local2 + 72) + 32) < 0 ? ((local2 + 72) + 32) : ((local2 + 72) + 32) + 0, (int) memory.readInt((int) (local3 + 32) < 0 ? (local3 + 32) : (local3 + 32) + 0)); + memory.writeLong((int) ((local2 + 72) + 24) < 0 ? ((local2 + 72) + 24) : ((local2 + 72) + 24) + 0, (long) memory.readLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0)); + local4 = (local3 + 16); + memory.writeLong((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + local6 = memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0); + memory.writeLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0, (long) local6); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 36, (byte) (0)); + local7 = ((local2 + 48) + 8); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) local6); + local8 = ((local2 + 48) + 16); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + local6 = memory.readLong((int) local3 < 0 ? local3 : local3 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) local6); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) local6); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 80); + callArgs_1[1] = ((long) (local2 + 72)); + callArgs_1[0] = ((long) (local2 + 32)); + instance.getMachine().call(545, callArgs_1); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 32); + local4 = (int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(538, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) arg1); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 48)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local4, 0) != 0 ? local3 : (local2 + 32))); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local2); + callArgs_3[2] = ((long) 29012); + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), -1) != 0) { + break label_2; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + instance.getMachine().call(1777, callArgs_4); + break label_2; + } + local5 = 0; + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + } + instance.global(0).setValue(((long) (local2 + 112))); + return local5; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1160(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1160(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1161(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 16); + local4 = 10; + local5 = 0; + label_1: { + label_2: { + label_3: while (true) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 120, (int) ((int) callResult_0[0])); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 124, (int) ((int) callResult_1[0])); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 120)); + int ciTableIdx_2 = (int) (arg1); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local2 + 32)); + long[] callResult_2 = ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + if (((int) callResult_2[0]) != 0) { + break label_2; + } + local6 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local7 = (local3 + (local6 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local7 < 0 ? local7 : local7 + 36) & 0xFF)) != 0) { + break label_1; + } + local8 = (local7 + 16); + memory.writeLong((int) ((local2 + 80) + 16) < 0 ? ((local2 + 80) + 16) : ((local2 + 80) + 16) + 0, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local6 ^ 1))); + memory.writeI32((int) ((local2 + 80) + 32) < 0 ? ((local2 + 80) + 32) : ((local2 + 80) + 32) + 0, (int) memory.readInt((int) (local7 + 32) < 0 ? (local7 + 32) : (local7 + 32) + 0)); + memory.writeLong((int) ((local2 + 80) + 24) < 0 ? ((local2 + 80) + 24) : ((local2 + 80) + 24) + 0, (long) memory.readLong((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0)); + local6 = (local7 + 8); + memory.writeLong((int) ((local2 + 80) + 8) < 0 ? ((local2 + 80) + 8) : ((local2 + 80) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 36, (byte) (0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 80, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(134, memory.readInt((int) local2 < 0 ? local2 : local2 + 100)) != 0) { + break label_4; + } + local9 = ((local2 + 56) + 16); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + local8 = ((local2 + 56) + 8); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 80); + callArgs_3[1] = ((long) (local2 + 80)); + callArgs_3[0] = ((long) (local2 + 40)); + instance.getMachine().call(545, callArgs_3); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) local9 < 0 ? local9 : local9 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 51), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 40) : (local2 + 40))); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) local2); + callArgs_4[2] = ((long) 28991); + callArgs_4[1] = ((long) (local2 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 51), -1) != 0) { + break label_4; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 40)); + instance.getMachine().call(1777, callArgs_5); + } + local4 = (local4 + -1); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local5 = 1; + } + instance.global(0).setValue(((long) (local2 + 128))); + return local5; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1161(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1161(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1162(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24)); + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + callArgs_0[0] = ((long) (local2 + 56)); + long[] callResult_0 = instance.getMachine().call(194, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + local3 = ((local2 + 32) + 16); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + local4 = ((local2 + 32) + 8); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 + 56)); + callArgs_1[0] = ((long) (local2 + 64)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 32)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 64)); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local2); + callArgs_2[2] = ((long) 11125); + callArgs_2[1] = ((long) (local2 + 8)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_2); + } + instance.global(0).setValue(((long) (local2 + 128))); + return; + } + + public static long[] call_1162(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1162(arg0, arg1, memory, instance); + return null; + } + + public static int func_1163(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + int local10 = 0; + int local11 = 0; + local3 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + local4 = (arg0 + 16); + local5 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_0[0] = ((long) (local3 + 88)); + instance.getMachine().call(557, callArgs_0); + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local6 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) * 40)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 88)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) ((local3 + 88) + 8) < 0 ? ((local3 + 88) + 8) : ((local3 + 88) + 8) + 0)); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) memory.readLong((int) ((local3 + 88) + 16) < 0 ? ((local3 + 88) + 16) : ((local3 + 88) + 16) + 0)); + memory.writeLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0, (long) memory.readLong((int) ((local3 + 88) + 24) < 0 ? ((local3 + 88) + 24) : ((local3 + 88) + 24) + 0)); + memory.writeI32((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0, (int) memory.readInt((int) ((local3 + 88) + 32) < 0 ? ((local3 + 88) + 32) : ((local3 + 88) + 32) + 0)); + label_3: { + if (((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + local5 = (local5 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF)) != 0) { + break label_1; + } + } + local6 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeI32((int) ((local3 + 88) + 32) < 0 ? ((local3 + 88) + 32) : ((local3 + 88) + 32) + 0, (int) memory.readInt((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0)); + memory.writeLong((int) ((local3 + 88) + 24) < 0 ? ((local3 + 88) + 24) : ((local3 + 88) + 24) + 0, (long) memory.readLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0)); + local7 = ((local3 + 88) + 16); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + local8 = ((local3 + 88) + 8); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + memory.writeByte((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36, (byte) (0)); + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 88, (long) local9); + memory.writeI32((int) ((local3 + 72) + 8) < 0 ? ((local3 + 72) + 8) : ((local3 + 72) + 8) + 0, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 72, (long) 0L); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4), memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0) { + break label_4; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 11); + callArgs_1[1] = ((long) 31108); + callArgs_1[0] = ((long) (local3 + 72)); + long[] callResult_1 = instance.getMachine().call(1649, callArgs_1); + label_5: { + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)) != 0) { + break label_5; + } + local5 = ((int) memory.read((int) local6 < 0 ? local6 : local6 + 11) & 0xFF); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local5), 0); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) (local4 != 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 4) : local5)); + callArgs_2[1] = ((long) (local4 != 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : local6)); + callArgs_2[0] = ((long) (local3 + 72)); + long[] callResult_2 = instance.getMachine().call(1652, callArgs_2); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 2) != 0) { + break label_5; + } + local5 = 12; + local4 = 1; + label_6: while (true) { + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local6 + -1), local4) != 0 ? 31060 : 31370)); + callArgs_3[0] = ((long) (local3 + 72)); + long[] callResult_3 = instance.getMachine().call(1662, callArgs_3); + local6 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + local5); + local10 = ((int) memory.read((int) (local6 + 11) < 0 ? (local6 + 11) : (local6 + 11) + 0) & 0xFF); + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local10), 0); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local11 != 0 ? memory.readInt((int) (local6 + 4) < 0 ? (local6 + 4) : (local6 + 4) + 0) : local10)); + callArgs_4[1] = ((long) (local11 != 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : local6)); + callArgs_4[0] = ((long) (local3 + 72)); + long[] callResult_4 = instance.getMachine().call(1652, callArgs_4); + local5 = (local5 + 12); + local4 = (local4 + 1); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_4; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 31357); + callArgs_5[0] = ((long) (local3 + 72)); + long[] callResult_5 = instance.getMachine().call(1662, callArgs_5); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) arg2); + callArgs_6[0] = ((long) (local3 + 72)); + long[] callResult_6 = instance.getMachine().call(1662, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 30613); + callArgs_7[0] = ((long) (local3 + 72)); + long[] callResult_7 = instance.getMachine().call(1662, callArgs_7); + } + local6 = ((local3 + 48) + 16); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + arg1 = ((local3 + 48) + 8); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 88)); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 80); + callArgs_8[1] = ((long) (local3 + 88)); + callArgs_8[0] = ((long) (local3 + 32)); + instance.getMachine().call(545, callArgs_8); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 48)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 32) : (local3 + 32))); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 83), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 72) : (local3 + 72))); + long[] callArgs_9 = new long[4]; + callArgs_9[3] = ((long) local3); + callArgs_9[2] = ((long) 28966); + callArgs_9[1] = ((long) (local3 + 8)); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_9); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 43), -1) != 0) { + break label_7; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 32)); + instance.getMachine().call(1777, callArgs_10); + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 83), -1) != 0) { + break label_8; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 72)); + instance.getMachine().call(1777, callArgs_11); + } + instance.global(0).setValue(((long) (local3 + 128))); + return 1; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1163(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1163(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1164(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = 0; + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_2; + } + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = ((arg0 + (local3 * 40)) + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1163, callArgs_1); + local3 = ((int) callResult_1[0]); + } + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1164(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1164(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1165(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + long local7 = 0L; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + local3 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, local3) != 0) { + break label_3; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local5 = ((arg0 + 16) + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (0)); + local6 = memory.readLong((int) local5 < 0 ? local5 : local5 + 24); + local7 = (local6 >>> 32L); + arg0 = (int) local7; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, 2147483632) != 0) { + break label_1; + } + local4 = (int) local6; + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 10) != 0) { + break label_5; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 11, (byte) (int) (local7)); + local5 = local2; + break label_4; + } + local8 = ((arg0 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local8); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) (local8 | -2147483648)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) arg0); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg0); + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + arg0) < 0 ? (((int) callResult_2[0]) + arg0) : (((int) callResult_2[0]) + arg0) + 0, (byte) (0)); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_6; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_3); + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + } + instance.global(0).setValue(((long) (local2 + 16))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(136, local3); + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1165(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1165(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1166(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(59, ((int) callResult_0[0])) != 0) { + break label_3; + } + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = ((arg0 + 16) + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeLong((int) ((local2 + 104) + 24) < 0 ? ((local2 + 104) + 24) : ((local2 + 104) + 24) + 0, (long) memory.readLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0)); + local5 = memory.readInt((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0); + memory.writeI32((int) ((local2 + 104) + 32) < 0 ? ((local2 + 104) + 32) : ((local2 + 104) + 32) + 0, (int) local5); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + memory.writeLong((int) ((local2 + 104) + 16) < 0 ? ((local2 + 104) + 16) : ((local2 + 104) + 16) + 0, (long) memory.readLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + local6 = ((local2 + 104) + 8); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + local3 = 0; + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 104, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + local4 = (local2 + 132); + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local8 = memory.readLong((int) local4 < 0 ? local4 : local4 + 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 96, (long) 4294967295L); + label_4: { + local4 = (int) local8; + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 + 96)); + callArgs_1[1] = ((long) (local4 + (int) (local8 >>> 32L))); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(547, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_1[0])) != 0) { + break label_4; + } + memory.writeI32((int) ((local2 + 16) + 16) < 0 ? ((local2 + 16) + 16) : ((local2 + 16) + 16) + 0, (int) memory.readInt((int) ((local2 + 104) + 16) < 0 ? ((local2 + 104) + 16) : ((local2 + 104) + 16) + 0)); + memory.writeLong((int) ((local2 + 16) + 8) < 0 ? ((local2 + 16) + 8) : ((local2 + 16) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local7); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local2); + callArgs_2[2] = ((long) 30733); + callArgs_2[1] = ((long) (local2 + 16)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_2); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local2 + 104)); + callArgs_3[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 96)); + callArgs_3[0] = ((long) (local2 + 56)); + long[] callResult_3 = instance.getMachine().call(155, callArgs_3); + arg0 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg0); + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(158, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + break label_2; + } + label_5: { + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 0); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_6[0])) != 0) { + break label_5; + } + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = ((arg0 + 16) + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + local3 = 0; + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + memory.writeI32((int) ((local2 + 104) + 32) < 0 ? ((local2 + 104) + 32) : ((local2 + 104) + 32) + 0, (int) memory.readInt((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0)); + local8 = memory.readLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0); + memory.writeLong((int) ((local2 + 104) + 24) < 0 ? ((local2 + 104) + 24) : ((local2 + 104) + 24) + 0, (long) local8); + memory.writeLong((int) ((local2 + 104) + 16) < 0 ? ((local2 + 104) + 16) : ((local2 + 104) + 16) + 0, (long) memory.readLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + memory.writeLong((int) ((local2 + 104) + 8) < 0 ? ((local2 + 104) + 8) : ((local2 + 104) + 8) + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 104, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) local8); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) local8); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (local2 + 104)); + callArgs_7[1] = ((long) (local2 + 40)); + callArgs_7[0] = ((long) (local2 + 56)); + long[] callResult_7 = instance.getMachine().call(156, callArgs_7); + arg0 = ((int) callResult_7[0]); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) arg0); + callArgs_8[0] = ((long) arg1); + long[] callResult_8 = instance.getMachine().call(158, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg0); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + break label_2; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) 16); + long[] callResult_10 = instance.getMachine().call(1776, callArgs_10); + local3 = ((int) callResult_10[0]); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 15, (byte) (0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 2210)); + memory.writeLong((int) (local3 + 7) < 0 ? (local3 + 7) : (local3 + 7) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 2217)); + arg1 = ((local2 + 104) + 16); + memory.writeShort((int) arg1 < 0 ? arg1 : arg1 + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 16986) & 0xFFFF))); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 112, (int) -2147483632); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 104, (int) local3); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 127, (byte) (6)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 122, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 116, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 16982)); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) 24); + long[] callResult_11 = instance.getMachine().call(1776, callArgs_11); + local4 = ((int) callResult_11[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 64, (int) (local4 + 24)); + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) 15); + callArgs_12[1] = ((long) local3); + callArgs_12[0] = ((long) local4); + instance.getMachine().call(1647, callArgs_12); + local3 = (local4 + 12); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 127), 0) != 0) { + break label_7; + } + arg1 = ((local2 + 104) + 12); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_6; + } + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_13[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 116)); + callArgs_13[0] = ((long) local3); + instance.getMachine().call(1647, callArgs_13); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 60, (int) (local4 + 24)); + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) 12204); + callArgs_14[1] = ((long) (local2 + 56)); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(1163, callArgs_14); + local3 = ((int) callResult_14[0]); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 23), -1) != 0) { + break label_8; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 12)); + instance.getMachine().call(1777, callArgs_15); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_9; + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_16); + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_17); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 127), -1) != 0) { + break label_10; + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 116)); + instance.getMachine().call(1777, callArgs_18); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 115), -1) != 0) { + break label_2; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 104)); + instance.getMachine().call(1777, callArgs_19); + } + instance.global(0).setValue(((long) (local2 + 144))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1166(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1166(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1167(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local2 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 2147483632) != 0) { + break label_1; + } + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 10) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 11, (byte) (local2)); + local3 = arg0; + break label_2; + } + local4 = ((local2 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local4 | -2147483648)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) local3); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local2) < 0 ? (((int) callResult_2[0]) + local2) : (((int) callResult_2[0]) + local2) + 0, (byte) (0)); + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1167(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1167(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1168(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + label_1: { + label_2: { + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 357913942) != 0) { + break label_1; + } + local3 = (local2 * 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local2 + local3)); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + label_3: while (true) { + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) (arg1 + 11) < 0 ? (arg1 + 11) : (arg1 + 11) + 0), 0) != 0) { + break label_5; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_4; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0)); + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1647, callArgs_1); + } + local2 = (local2 + 12); + arg1 = (arg1 + 12); + local3 = (local3 + -12); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + } + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1168(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1168(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1169(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + local2 = (local3 + -12); + label_3: while (true) { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + 11) < 0 ? (local2 + 11) : (local2 + 11) + 0), -1) != 0) { + break label_4; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local2); + local2 = (local2 + -12); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + } + return arg0; + } + + public static long[] call_1169(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1169(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1170(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(59, ((int) callResult_0[0])) != 0) { + break label_2; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_1[0])) != 0) { + break label_1; + } + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1166, callArgs_2); + return 1; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg2); + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(160, callArgs_3); + return 0; + } + + public static long[] call_1170(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1170(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1171(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = 0; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1172, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 16); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local4 = ((int) callResult_1[0]); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 14, (byte) (0)); + memory.writeLong((int) (local4 + 6) < 0 ? (local4 + 6) : (local4 + 6) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 11344)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 11338)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 12); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + local3 = (arg1 + 12); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local3); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 14); + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) arg1); + instance.getMachine().call(1647, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 30515); + callArgs_4[1] = ((long) local2); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1163, callArgs_4); + local3 = ((int) callResult_4[0]); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_2; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_5); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_6); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_7); + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_1171(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1171(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1172(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = 0; + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(36, ((int) callResult_1[0])) != 0) { + break label_3; + } + local3 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local2 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local2 < 0 ? local2 : local2 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local2 + 36) < 0 ? (local2 + 36) : (local2 + 36) + 0, (byte) (0)); + local2 = 1; + local5 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + local3 = (local3 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1173, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_2; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 44); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1160, callArgs_3); + return 1; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 0); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1154, callArgs_4); + local4 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + local3 = ((int) callResult_5[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, local4) != 0) { + break label_2; + } + label_4: { + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + long[] callResult_6 = instance.getMachine().call(1156, callArgs_6); + if (((int) callResult_6[0]) != 0) { + break label_4; + } + label_5: { + switch((local3 + -90)) { + case 0: + { + break label_4; + } + case 1: + { + break label_2; + } + case 2: + { + break label_2; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_4; + } + case 6: + { + break label_2; + } + case 7: + { + break label_2; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_2; + } + case 19: + { + break label_2; + } + case 20: + { + break label_2; + } + case 21: + { + break label_2; + } + case 22: + { + break label_2; + } + case 23: + { + break label_2; + } + case 24: + { + break label_2; + } + case 25: + { + break label_2; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_2; + } + case 29: + { + break label_2; + } + case 30: + { + break label_2; + } + case 31: + { + break label_2; + } + case 32: + { + break label_2; + } + case 33: + { + break label_2; + } + case 34: + { + break label_2; + } + case 35: + { + break label_2; + } + case 36: + { + break label_2; + } + case 37: + { + break label_4; + } + case 38: + { + break label_4; + } + default: + { + break label_5; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(68, local3) != 0) { + break label_2; + } + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1174, callArgs_7); + local2 = 1; + } + return local2; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1172(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1172(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1173(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1175, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 11, (byte) (8)); + local4 = 0; + local5 = (local2 + 8); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 8247343735669550689L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 12); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + local5 = (arg1 + 12); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local5); + label_1: { + label_2: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1154, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_2[0])) != 0) { + break label_2; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local5 = ((arg0 + (local4 * 40)) + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) (local2 + 16)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1163, callArgs_3); + local4 = ((int) callResult_3[0]); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_3; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_5); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 11), -1) != 0) { + break label_4; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_6); + } + instance.global(0).setValue(((long) (local2 + 32))); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4) != 0 ? 1 : local3); + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1173(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1173(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1174(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[15]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = (((int) instance.global(0).getValue()) - 272); + instance.global(0).setValue(((long) iL[2])); + iL[3] = 1; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) iL[0]); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_1; + } + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) iL[0]); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) ((int) callResult_1[0])); + long[] callResult_2 = instance.getMachine().call(1156, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_2[0])) != 0) { + break label_7; + } + iL[4] = (iL[0] + 16); + iL[3] = ((int) memory.read((int) (iL[0] + 96) < 0 ? (iL[0] + 96) : (iL[0] + 96) + 0) & 0xFF); + iL[5] = (iL[4] + (iL[3] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + break label_4; + } + memory.writeByte((int) (iL[5] + 36) < 0 ? (iL[5] + 36) : (iL[5] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[3] ^ 1))); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 176, (int) 0); + iL[5] = 0; + label_8: { + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (iL[2] + 176)); + callArgs_3[0] = ((long) iL[0]); + long[] callResult_3 = instance.getMachine().call(1176, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_8; + } + iL[5] = 0; + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) iL[1]); + callArgs_4[0] = ((long) iL[0]); + long[] callResult_4 = instance.getMachine().call(1177, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_8; + } + memory.writeByte((int) iL[2] < 0 ? iL[2] : iL[2] + 131, (byte) (7)); + iL[6] = 0; + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 120, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 11353)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 123, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 11356)); + memory.writeByte((int) iL[2] < 0 ? iL[2] : iL[2] + 127, (byte) (0)); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 12); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + iL[3] = ((int) callResult_5[0]); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 120)); + memory.writeI32((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0, (int) memory.readInt((int) ((iL[2] + 120) + 8) < 0 ? ((iL[2] + 120) + 8) : ((iL[2] + 120) + 8) + 0)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 208, (int) iL[3]); + iL[5] = (iL[3] + 12); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 216, (int) iL[5]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 212, (int) iL[5]); + label_9: { + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 0); + callArgs_6[0] = ((long) iL[0]); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_6[0])) != 0) { + break label_9; + } + iL[5] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[4] = (iL[4] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 36) & 0xFF)) != 0) { + break label_4; + } + memory.writeByte((int) (iL[4] + 36) < 0 ? (iL[4] + 36) : (iL[4] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) (iL[2] + 208)); + callArgs_7[0] = ((long) iL[0]); + long[] callResult_7 = instance.getMachine().call(1163, callArgs_7); + iL[6] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_7[0])); + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 11), -1) != 0) { + break label_10; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + instance.getMachine().call(1777, callArgs_8); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) iL[3]); + instance.getMachine().call(1777, callArgs_9); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[2] < 0 ? iL[2] : iL[2] + 131), -1) != 0) { + break label_11; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 120)); + instance.getMachine().call(1777, callArgs_10); + } + iL[5] = 0; + if (iL[6] != 0) { + break label_8; + } + iL[3] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 176); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 176, (int) 0); + iL[5] = iL[1]; + label_12: { + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_12; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 8, (int) iL[4]); + iL[5] = (iL[4] + 4); + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) iL[3]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[3]); + iL[5] = 1; + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) (memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8) + 1)); + } + iL[3] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 176); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 176, (int) 0); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_13; + } + int ciTableIdx_11 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_11 = instance.table(0).requiredRef(ciTableIdx_11); + com.dylibso.chicory.runtime.Instance ciRefInstance_11 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_11), instance); + if (!ciRefInstance_11.type(ciRefInstance_11.functionType(ciFuncId_11)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) iL[3]); + ciRefInstance_11.getMachine().call(ciFuncId_11, callArgs_11); + } + iL[3] = 1; + if (iL[5] != 0) { + break label_6; + } + break label_1; + } + label_14: { + iL[4] = (iL[0] + 16); + iL[3] = ((int) memory.read((int) (iL[0] + 96) < 0 ? (iL[0] + 96) : (iL[0] + 96) + 0) & 0xFF); + if (((int) memory.read((int) (iL[4] + (iL[3] * 40)) < 0 ? (iL[4] + (iL[3] * 40)) : (iL[4] + (iL[3] * 40)) + 36) & 0xFF) != 0) { + break label_14; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + callArgs_12[0] = ((long) (iL[2] + 208)); + instance.getMachine().call(557, callArgs_12); + iL[3] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[5] = (iL[4] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) * 40)); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 208)); + memory.writeLong((int) (iL[5] + 8) < 0 ? (iL[5] + 8) : (iL[5] + 8) + 0, (long) memory.readLong((int) ((iL[2] + 208) + 8) < 0 ? ((iL[2] + 208) + 8) : ((iL[2] + 208) + 8) + 0)); + memory.writeLong((int) (iL[5] + 16) < 0 ? (iL[5] + 16) : (iL[5] + 16) + 0, (long) memory.readLong((int) ((iL[2] + 208) + 16) < 0 ? ((iL[2] + 208) + 16) : ((iL[2] + 208) + 16) + 0)); + memory.writeLong((int) (iL[5] + 24) < 0 ? (iL[5] + 24) : (iL[5] + 24) + 0, (long) memory.readLong((int) ((iL[2] + 208) + 24) < 0 ? ((iL[2] + 208) + 24) : ((iL[2] + 208) + 24) + 0)); + memory.writeI32((int) (iL[5] + 32) < 0 ? (iL[5] + 32) : (iL[5] + 32) + 0, (int) memory.readInt((int) ((iL[2] + 208) + 32) < 0 ? ((iL[2] + 208) + 32) : ((iL[2] + 208) + 32) + 0)); + label_15: { + if (((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF) != 0) { + break label_15; + } + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 36, (byte) (1)); + } + if (((int) memory.read((int) (iL[4] + (iL[3] * 40)) < 0 ? (iL[4] + (iL[3] * 40)) : (iL[4] + (iL[3] * 40)) + 36) & 0xFF) != 0) { + break label_14; + } + iL[3] = (iL[3] ^ 1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[3])); + } + iL[3] = (iL[4] + (iL[3] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + break label_4; + } + memory.writeLong((int) ((iL[2] + 152) + 8) < 0 ? ((iL[2] + 152) + 8) : ((iL[2] + 152) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeI32((int) ((iL[2] + 152) + 16) < 0 ? ((iL[2] + 152) + 16) : ((iL[2] + 152) + 16) + 0, (int) memory.readInt((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 152, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + iL[3] = 1; + label_16: { + label_17: { + int _d0 = func_1174__h0(iL, memory, instance); + if (_d0 == 1) + break label_1; + if (_d0 == 2) + break label_4; + if (_d0 == 3) + break label_16; + if (_d0 == 4) + break label_2; + if (_d0 == 5) + break label_3; + } + iL[5] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[3] = (iL[4] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + break label_4; + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[6] = (iL[5] ^ 1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[6])); + iL[3] = (iL[4] + (iL[6] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + break label_4; + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[5])); + iL[5] = ((iL[2] + 120) + 16); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + iL[13] = ((iL[2] + 120) + 8); + memory.writeLong((int) iL[13] < 0 ? iL[13] : iL[13] + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) (iL[4] + (iL[6] * 40)) < 0 ? (iL[4] + (iL[6] * 40)) : (iL[4] + (iL[6] * 40)) + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 120, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 200, (int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 24)); + label_52: { + long[] callArgs_83 = new long[2]; + callArgs_83[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12)); + callArgs_83[0] = ((long) (iL[2] + 200)); + long[] callResult_83 = instance.getMachine().call(194, callArgs_83); + if (((int) callResult_83[0]) != 0) { + break label_52; + } + iL[3] = ((iL[2] + 176) + 16); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[5] = ((iL[2] + 176) + 8); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) iL[13] < 0 ? iL[13] : iL[13] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 176, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 120)); + long[] callArgs_84 = new long[2]; + callArgs_84[1] = ((long) (iL[2] + 200)); + callArgs_84[0] = ((long) (iL[2] + 208)); + instance.getMachine().call(192, callArgs_84); + memory.writeLong((int) ((iL[2] + 80) + 8) < 0 ? ((iL[2] + 80) + 8) : ((iL[2] + 80) + 8) + 0, (long) memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + memory.writeI32((int) ((iL[2] + 80) + 16) < 0 ? ((iL[2] + 80) + 16) : ((iL[2] + 80) + 16) + 0, (int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 80, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 176)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 64, (int) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 208)); + long[] callArgs_85 = new long[4]; + callArgs_85[3] = ((long) (iL[2] + 64)); + callArgs_85[2] = ((long) 11125); + callArgs_85[1] = ((long) (iL[2] + 80)); + callArgs_85[0] = ((long) iL[0]); + instance.getMachine().call(1151, callArgs_85); + } + long[] callArgs_86 = new long[1]; + callArgs_86[0] = ((long) 196); + long[] callResult_86 = instance.getMachine().call(1776, callArgs_86); + iL[5] = ((int) callResult_86[0]); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 4, (long) 0L); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 32, (int) 62); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 36, (long) 0L); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) 58148); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 152)); + memory.writeLong((int) (iL[5] + 20) < 0 ? (iL[5] + 20) : (iL[5] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 152) + 8) < 0 ? ((iL[2] + 152) + 8) : ((iL[2] + 152) + 8) + 0)); + memory.writeI32((int) (iL[5] + 28) < 0 ? (iL[5] + 28) : (iL[5] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 152) + 16) < 0 ? ((iL[2] + 152) + 16) : ((iL[2] + 152) + 16) + 0)); + memory.writeLong((int) (iL[5] + 41) < 0 ? (iL[5] + 41) : (iL[5] + 41) + 0, (long) 0L); + long[] callArgs_87 = new long[1]; + callArgs_87[0] = ((long) (iL[5] + 52)); + long[] callResult_87 = instance.getMachine().call(154, callArgs_87); + memory.writeLong((int) (iL[5] + 120) < 0 ? (iL[5] + 120) : (iL[5] + 120) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 112) < 0 ? (iL[5] + 112) : (iL[5] + 112) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 104) < 0 ? (iL[5] + 104) : (iL[5] + 104) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 96) < 0 ? (iL[5] + 96) : (iL[5] + 96) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 88) < 0 ? (iL[5] + 88) : (iL[5] + 88) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 132) < 0 ? (iL[5] + 132) : (iL[5] + 132) + 0, (long) 0L); + memory.writeI32((int) (iL[5] + 128) < 0 ? (iL[5] + 128) : (iL[5] + 128) + 0, (int) 1065353216); + memory.writeLong((int) (iL[5] + 140) < 0 ? (iL[5] + 140) : (iL[5] + 140) + 0, (long) 0L); + iL[4] = (iL[5] + 152); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (long) 0L); + memory.writeI32((int) (iL[5] + 148) < 0 ? (iL[5] + 148) : (iL[5] + 148) + 0, (int) 1065353216); + memory.writeLong((int) (iL[5] + 160) < 0 ? (iL[5] + 160) : (iL[5] + 160) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 168) < 0 ? (iL[5] + 168) : (iL[5] + 168) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 176) < 0 ? (iL[5] + 176) : (iL[5] + 176) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 184) < 0 ? (iL[5] + 184) : (iL[5] + 184) + 0, (long) 0L); + memory.writeI32((int) (iL[5] + 192) < 0 ? (iL[5] + 192) : (iL[5] + 192) + 0, (int) 0); + iL[3] = 1; + long[] callArgs_88 = new long[2]; + callArgs_88[1] = ((long) (iL[5] + 36)); + callArgs_88[0] = ((long) iL[0]); + long[] callResult_88 = instance.getMachine().call(1178, callArgs_88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_88[0])) != 0) { + break label_5; + } + long[] callArgs_89 = new long[2]; + callArgs_89[1] = ((long) (iL[5] + 48)); + callArgs_89[0] = ((long) iL[0]); + long[] callResult_89 = instance.getMachine().call(1180, callArgs_89); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_89[0])) != 0) { + break label_5; + } + long[] callArgs_90 = new long[2]; + callArgs_90[1] = ((long) (iL[5] + 184)); + callArgs_90[0] = ((long) iL[0]); + long[] callResult_90 = instance.getMachine().call(1182, callArgs_90); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_90[0])) != 0) { + break label_5; + } + long[] callArgs_91 = new long[2]; + callArgs_91[1] = ((long) iL[4]); + callArgs_91[0] = ((long) iL[0]); + long[] callResult_91 = instance.getMachine().call(1175, callArgs_91); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_91[0])) != 0) { + break label_5; + } + long[] callArgs_92 = new long[2]; + callArgs_92[1] = ((long) iL[0]); + callArgs_92[0] = ((long) (iL[2] + 208)); + instance.getMachine().call(1153, callArgs_92); + memory.writeI32((int) (iL[5] + 180) < 0 ? (iL[5] + 180) : (iL[5] + 180) + 0, (int) memory.readInt((int) (iL[2] + 224) < 0 ? (iL[2] + 224) : (iL[2] + 224) + 0)); + memory.writeLong((int) (iL[5] + 172) < 0 ? (iL[5] + 172) : (iL[5] + 172) + 0, (long) memory.readLong((int) ((iL[2] + 208) + 8) < 0 ? ((iL[2] + 208) + 8) : ((iL[2] + 208) + 8) + 0)); + memory.writeLong((int) (iL[5] + 164) < 0 ? (iL[5] + 164) : (iL[5] + 164) + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 208)); + iL[3] = iL[1]; + label_53: { + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_53; + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 8, (int) iL[4]); + iL[3] = (iL[4] + 4); + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (int) iL[5]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[5]); + iL[7] = (iL[1] + 8); + } + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) (memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0) + 1)); + } + long[] callArgs_93 = new long[2]; + callArgs_93[1] = ((long) 44); + callArgs_93[0] = ((long) iL[0]); + long[] callResult_93 = instance.getMachine().call(1160, callArgs_93); + iL[3] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_93[0])); + break label_1; + } + int ciTableIdx_94 = (int) (memory.readInt((int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) < 0 ? memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) : memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + 4)); + int ciFuncId_94 = instance.table(0).requiredRef(ciTableIdx_94); + com.dylibso.chicory.runtime.Instance ciRefInstance_94 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_94), instance); + if (!ciRefInstance_94.type(ciRefInstance_94.functionType(ciFuncId_94)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_94 = new long[1]; + callArgs_94[0] = ((long) iL[5]); + ciRefInstance_94.getMachine().call(ciFuncId_94, callArgs_94); + break label_1; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + int ciTableIdx_96 = (int) (memory.readInt((int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) < 0 ? memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) : memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + 4)); + int ciFuncId_96 = instance.table(0).requiredRef(ciTableIdx_96); + com.dylibso.chicory.runtime.Instance ciRefInstance_96 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_96), instance); + if (!ciRefInstance_96.type(ciRefInstance_96.functionType(ciFuncId_96)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_96 = new long[1]; + callArgs_96[0] = ((long) iL[5]); + ciRefInstance_96.getMachine().call(ciFuncId_96, callArgs_96); + break label_1; + } + int ciTableIdx_97 = (int) (memory.readInt((int) memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0) < 0 ? memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0) : memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0) + 4)); + int ciFuncId_97 = instance.table(0).requiredRef(ciTableIdx_97); + com.dylibso.chicory.runtime.Instance ciRefInstance_97 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_97), instance); + if (!ciRefInstance_97.type(ciRefInstance_97.functionType(ciFuncId_97)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_97 = new long[1]; + callArgs_97[0] = ((long) iL[8]); + ciRefInstance_97.getMachine().call(ciFuncId_97, callArgs_97); + } + instance.global(0).setValue(((long) (iL[2] + 272))); + return iL[3]; + } + + public static long[] call_1174(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1174(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1175(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local2 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) 0L); + local3 = (arg0 + 16); + label_1: { + label_2: { + label_3: while (true) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + local5 = ((int) callResult_1[0]); + label_4: { + label_5: { + label_6: { + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(1156, callArgs_2); + if (((int) callResult_2[0]) != 0) { + break label_6; + } + local6 = 0; + label_7: { + switch((local4 + -90)) { + case 0: + { + break label_6; + } + case 1: + { + break label_2; + } + case 2: + { + break label_2; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_6; + } + case 6: + { + break label_2; + } + case 7: + { + break label_2; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_2; + } + case 19: + { + break label_2; + } + case 20: + { + break label_2; + } + case 21: + { + break label_2; + } + case 22: + { + break label_2; + } + case 23: + { + break label_2; + } + case 24: + { + break label_2; + } + case 25: + { + break label_2; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_2; + } + case 29: + { + break label_2; + } + case 30: + { + break label_2; + } + case 31: + { + break label_2; + } + case 32: + { + break label_2; + } + case 33: + { + break label_2; + } + case 34: + { + break label_2; + } + case 35: + { + break label_2; + } + case 36: + { + break label_2; + } + case 37: + { + break label_6; + } + case 38: + { + break label_6; + } + case 39: + { + break label_2; + } + case 40: + { + break label_2; + } + case 41: + { + break label_2; + } + case 42: + { + break label_5; + } + default: + { + break label_7; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(68, local4) != 0) { + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, local4) != 0) { + break label_2; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local5); + long[] callResult_3 = instance.getMachine().call(1156, callArgs_3); + if (((int) callResult_3[0]) != 0) { + break label_6; + } + label_8: { + switch((local5 + -90)) { + case 0: + { + break label_6; + } + case 1: + { + break label_2; + } + case 2: + { + break label_2; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_6; + } + case 6: + { + break label_2; + } + case 7: + { + break label_2; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_2; + } + case 19: + { + break label_2; + } + case 20: + { + break label_2; + } + case 21: + { + break label_2; + } + case 22: + { + break label_2; + } + case 23: + { + break label_2; + } + case 24: + { + break label_2; + } + case 25: + { + break label_2; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_2; + } + case 29: + { + break label_2; + } + case 30: + { + break label_2; + } + case 31: + { + break label_2; + } + case 32: + { + break label_2; + } + case 33: + { + break label_2; + } + case 34: + { + break label_2; + } + case 35: + { + break label_2; + } + case 36: + { + break label_2; + } + case 37: + { + break label_6; + } + case 38: + { + break label_6; + } + default: + { + break label_8; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(68, local5) != 0) { + break label_2; + } + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 32)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1254, callArgs_4); + if (((int) callResult_4[0]) != 0) { + break label_4; + } + local7 = memory.readInt((int) local2 < 0 ? local2 : local2 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + local8 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + local9 = memory.readInt((int) local2 < 0 ? local2 : local2 + 40); + local4 = local7; + label_9: while (true) { + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local2 < 0 ? local2 : local2 + 36), local7) != 0) { + break label_11; + } + local10 = local5; + local6 = local5; + label_12: { + local11 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_12; + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 4, (int) local5); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local10 = local7; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_13; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local11); + local7 = local10; + break label_10; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) local11); + local7 = local10; + break label_10; + } + local7 = 0; + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) 0); + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + local6 = arg1; + label_14: { + local10 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_14; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local10); + local6 = (local10 + 4); + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local4); + local9 = (local9 + -1); + local8 = (local8 + 1); + local4 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) local9); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) local7); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + label_15: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local2 + 32)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1255, callArgs_5); + if (((int) callResult_5[0]) != 0) { + break label_15; + } + local7 = memory.readInt((int) local2 < 0 ? local2 : local2 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + local8 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + local9 = memory.readInt((int) local2 < 0 ? local2 : local2 + 40); + local4 = local7; + label_16: while (true) { + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + label_17: { + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local2 < 0 ? local2 : local2 + 36), local7) != 0) { + break label_18; + } + local10 = local5; + local6 = local5; + label_19: { + local11 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_19; + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 4, (int) local5); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local10 = local7; + } + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_20; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local11); + local7 = local10; + break label_17; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) local11); + local7 = local10; + break label_17; + } + local7 = 0; + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) 0); + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + local6 = arg1; + label_21: { + local10 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_21; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local10); + local6 = (local10 + 4); + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local4); + local9 = (local9 + -1); + local8 = (local8 + 1); + local4 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + break; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) local9); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) local7); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + local5 = 10; + label_22: while (true) { + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 0); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + local4 = ((int) callResult_6[0]); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1154, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(132, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + local6 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local4 = (local3 + (local6 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + local7 = (local4 + 16); + memory.writeLong((int) ((local2 + 88) + 16) < 0 ? ((local2 + 88) + 16) : ((local2 + 88) + 16) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local6 ^ 1))); + memory.writeI32((int) ((local2 + 88) + 32) < 0 ? ((local2 + 88) + 32) : ((local2 + 88) + 32) + 0, (int) memory.readInt((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0)); + memory.writeLong((int) ((local2 + 88) + 24) < 0 ? ((local2 + 88) + 24) : ((local2 + 88) + 24) + 0, (long) memory.readLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0)); + local6 = (local4 + 8); + memory.writeLong((int) ((local2 + 88) + 8) < 0 ? ((local2 + 88) + 8) : ((local2 + 88) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 88, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(134, memory.readInt((int) local2 < 0 ? local2 : local2 + 108)) != 0) { + break label_23; + } + local10 = ((local2 + 64) + 16); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + local7 = ((local2 + 64) + 8); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 64, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 80); + callArgs_8[1] = ((long) (local2 + 88)); + callArgs_8[0] = ((long) (local2 + 48)); + instance.getMachine().call(545, callArgs_8); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) local10 < 0 ? local10 : local10 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 59), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 48) : (local2 + 48))); + long[] callArgs_9 = new long[4]; + callArgs_9[3] = ((long) local2); + callArgs_9[2] = ((long) 28991); + callArgs_9[1] = ((long) (local2 + 8)); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 59), -1) != 0) { + break label_23; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 48)); + instance.getMachine().call(1777, callArgs_10); + } + local5 = (local5 + -1); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_22; + } + break; + } + local6 = 1; + break label_2; + } + local6 = 1; + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 665); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1161, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_11[0])) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + label_24: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_24; + } + label_25: while (true) { + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + int ciTableIdx_12 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_12 = instance.table(0).requiredRef(ciTableIdx_12); + com.dylibso.chicory.runtime.Instance ciRefInstance_12 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_12), instance); + if (!ciRefInstance_12.type(ciRefInstance_12.functionType(ciFuncId_12)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local4); + ciRefInstance_12.getMachine().call(ciFuncId_12, callArgs_12); + local4 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_25; + } + break; + } + } + instance.global(0).setValue(((long) (local2 + 128))); + return local6; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1175(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1175(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1176(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[9]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = (((int) instance.global(0).getValue()) - 1712); + instance.global(0).setValue(((long) iL[2])); + label_1: { + iL[3] = (iL[0] + 16); + iL[4] = (iL[0] + 96); + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + if (((int) memory.read((int) (iL[3] + (iL[5] * 40)) < 0 ? (iL[3] + (iL[5] * 40)) : (iL[3] + (iL[5] * 40)) + 36) & 0xFF) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + callArgs_0[0] = ((long) (iL[2] + 1520)); + instance.getMachine().call(557, callArgs_0); + iL[5] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[6] = (iL[3] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) * 40)); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520)); + memory.writeLong((int) (iL[6] + 8) < 0 ? (iL[6] + 8) : (iL[6] + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0)); + memory.writeLong((int) (iL[6] + 16) < 0 ? (iL[6] + 16) : (iL[6] + 16) + 0, (long) memory.readLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0)); + memory.writeLong((int) (iL[6] + 24) < 0 ? (iL[6] + 24) : (iL[6] + 24) + 0, (long) memory.readLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0)); + memory.writeI32((int) (iL[6] + 32) < 0 ? (iL[6] + 32) : (iL[6] + 32) + 0, (int) memory.readInt((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0)); + label_2: { + if (((int) memory.read((int) iL[6] < 0 ? iL[6] : iL[6] + 36) & 0xFF) != 0) { + break label_2; + } + memory.writeByte((int) iL[6] < 0 ? iL[6] : iL[6] + 36, (byte) (1)); + } + if (((int) memory.read((int) (iL[3] + (iL[5] * 40)) < 0 ? (iL[3] + (iL[5] * 40)) : (iL[3] + (iL[5] * 40)) + 36) & 0xFF) != 0) { + break label_1; + } + iL[5] = (iL[5] ^ 1); + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (byte) (iL[5])); + } + label_3: { + label_4: { + label_5: { + iL[5] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + break label_5; + } + memory.writeLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0, (long) memory.readLong((int) (iL[5] + 8) < 0 ? (iL[5] + 8) : (iL[5] + 8) + 0)); + memory.writeI32((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0, (int) memory.readInt((int) (iL[5] + 16) < 0 ? (iL[5] + 16) : (iL[5] + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688, (long) memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[5] = 1; + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + int _d1 = func_1176__h1(iL, memory, instance); + if (_d1 == 1) + break label_3; + if (_d1 == 2) + break label_10; + if (_d1 == 3) + break label_9; + if (_d1 == 4) + break label_8; + if (_d1 == 5) + break label_7; + if (_d1 == 6) + break label_11; + if (_d1 == 7) + break label_5; + if (_d1 == 8) + break label_6; + if (_d1 == 9) + break label_4; + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + break label_5; + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + iL[4] = ((iL[2] + 1520) + 32); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + iL[6] = ((iL[2] + 1520) + 24); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + iL[7] = ((iL[2] + 1520) + 16); + memory.writeLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + iL[8] = ((iL[2] + 1520) + 8); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_187 = new long[2]; + callArgs_187[1] = ((long) (iL[2] + 1520)); + callArgs_187[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_187); + memory.writeI32((int) ((iL[2] + 944) + 16) < 0 ? ((iL[2] + 944) + 16) : ((iL[2] + 944) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 944) + 8) < 0 ? ((iL[2] + 944) + 8) : ((iL[2] + 944) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) ((iL[2] + 904) + 8) < 0 ? ((iL[2] + 904) + 8) : ((iL[2] + 904) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + memory.writeLong((int) ((iL[2] + 904) + 16) < 0 ? ((iL[2] + 904) + 16) : ((iL[2] + 904) + 16) + 0, (long) memory.readLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0)); + memory.writeLong((int) ((iL[2] + 904) + 24) < 0 ? ((iL[2] + 904) + 24) : ((iL[2] + 904) + 24) + 0, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + memory.writeI32((int) ((iL[2] + 904) + 32) < 0 ? ((iL[2] + 904) + 32) : ((iL[2] + 904) + 32) + 0, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 944, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 904, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520)); + long[] callArgs_188 = new long[4]; + callArgs_188[3] = ((long) iL[1]); + callArgs_188[2] = ((long) (iL[2] + 904)); + callArgs_188[1] = ((long) (iL[2] + 944)); + callArgs_188[0] = ((long) iL[0]); + long[] callResult_188 = instance.getMachine().call(1293, callArgs_188); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_188[0])) != 0) { + break label_6; + } + break label_3; + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + break label_5; + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + iL[5] = ((iL[2] + 1520) + 24); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_189 = new long[2]; + callArgs_189[1] = ((long) (iL[2] + 1520)); + callArgs_189[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_189); + long[] callArgs_190 = new long[1]; + callArgs_190[0] = ((long) 40); + long[] callResult_190 = instance.getMachine().call(1776, callArgs_190); + iL[0] = ((int) callResult_190[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 58); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 57260); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 36, (int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_6; + } + int ciTableIdx_191 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_191 = instance.table(0).requiredRef(ciTableIdx_191); + com.dylibso.chicory.runtime.Instance ciRefInstance_191 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_191), instance); + if (!ciRefInstance_191.type(ciRefInstance_191.functionType(ciFuncId_191)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_191 = new long[1]; + callArgs_191[0] = ((long) iL[3]); + ciRefInstance_191.getMachine().call(ciFuncId_191, callArgs_191); + break label_6; + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + break label_5; + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_192 = new long[2]; + callArgs_192[1] = ((long) (iL[2] + 1520)); + callArgs_192[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_192); + iL[3] = ((iL[2] + 1688) + 8); + memory.writeLong((int) ((iL[2] + 968) + 8) < 0 ? ((iL[2] + 968) + 8) : ((iL[2] + 968) + 8) + 0, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + iL[4] = ((iL[2] + 1688) + 16); + memory.writeI32((int) ((iL[2] + 968) + 16) < 0 ? ((iL[2] + 968) + 16) : ((iL[2] + 968) + 16) + 0, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1480, (long) 0L); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 968, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_193 = new long[3]; + callArgs_193[2] = ((long) (iL[2] + 1480)); + callArgs_193[1] = ((long) (iL[2] + 968)); + callArgs_193[0] = ((long) iL[0]); + long[] callResult_193 = instance.getMachine().call(1294, callArgs_193); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_193[0])) != 0) { + break label_3; + } + long[] callArgs_194 = new long[1]; + callArgs_194[0] = ((long) 48); + long[] callResult_194 = instance.getMachine().call(1776, callArgs_194); + iL[0] = ((int) callResult_194[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 43); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 49364); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 40, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1480)); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 36, (int) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 1544)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_6; + } + int ciTableIdx_195 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_195 = instance.table(0).requiredRef(ciTableIdx_195); + com.dylibso.chicory.runtime.Instance ciRefInstance_195 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_195), instance); + if (!ciRefInstance_195.type(ciRefInstance_195.functionType(ciFuncId_195)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_195 = new long[1]; + callArgs_195[0] = ((long) iL[3]); + ciRefInstance_195.getMachine().call(ciFuncId_195, callArgs_195); + break label_6; + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + break label_5; + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeI32((int) ((iL[2] + 1032) + 16) < 0 ? ((iL[2] + 1032) + 16) : ((iL[2] + 1032) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1032) + 8) < 0 ? ((iL[2] + 1032) + 8) : ((iL[2] + 1032) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1032, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) ((iL[2] + 992) + 8) < 0 ? ((iL[2] + 992) + 8) : ((iL[2] + 992) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeLong((int) ((iL[2] + 992) + 16) < 0 ? ((iL[2] + 992) + 16) : ((iL[2] + 992) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 992) + 24) < 0 ? ((iL[2] + 992) + 24) : ((iL[2] + 992) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeI32((int) ((iL[2] + 992) + 32) < 0 ? ((iL[2] + 992) + 32) : ((iL[2] + 992) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 992, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_196 = new long[4]; + callArgs_196[3] = ((long) iL[1]); + callArgs_196[2] = ((long) (iL[2] + 992)); + callArgs_196[1] = ((long) (iL[2] + 1032)); + callArgs_196[0] = ((long) iL[0]); + long[] callResult_196 = instance.getMachine().call(1295, callArgs_196); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_196[0])) != 0) { + break label_6; + } + break label_3; + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + break label_5; + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeI32((int) ((iL[2] + 1096) + 16) < 0 ? ((iL[2] + 1096) + 16) : ((iL[2] + 1096) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1096) + 8) < 0 ? ((iL[2] + 1096) + 8) : ((iL[2] + 1096) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1096, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) ((iL[2] + 1056) + 8) < 0 ? ((iL[2] + 1056) + 8) : ((iL[2] + 1056) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeLong((int) ((iL[2] + 1056) + 16) < 0 ? ((iL[2] + 1056) + 16) : ((iL[2] + 1056) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1056) + 24) < 0 ? ((iL[2] + 1056) + 24) : ((iL[2] + 1056) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeI32((int) ((iL[2] + 1056) + 32) < 0 ? ((iL[2] + 1056) + 32) : ((iL[2] + 1056) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1056, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_197 = new long[4]; + callArgs_197[3] = ((long) iL[1]); + callArgs_197[2] = ((long) (iL[2] + 1056)); + callArgs_197[1] = ((long) (iL[2] + 1096)); + callArgs_197[0] = ((long) iL[0]); + long[] callResult_197 = instance.getMachine().call(1296, callArgs_197); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_197[0])) != 0) { + break label_6; + } + break label_3; + } + iL[6] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[5] = (iL[3] + (iL[6] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + break label_5; + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[6] ^ 1))); + memory.writeI32((int) ((iL[2] + 1480) + 32) < 0 ? ((iL[2] + 1480) + 32) : ((iL[2] + 1480) + 32) + 0, (int) memory.readInt((int) (iL[5] + 32) < 0 ? (iL[5] + 32) : (iL[5] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1480) + 24) < 0 ? ((iL[2] + 1480) + 24) : ((iL[2] + 1480) + 24) + 0, (long) memory.readLong((int) (iL[5] + 24) < 0 ? (iL[5] + 24) : (iL[5] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1480) + 16) < 0 ? ((iL[2] + 1480) + 16) : ((iL[2] + 1480) + 16) + 0, (long) memory.readLong((int) (iL[5] + 16) < 0 ? (iL[5] + 16) : (iL[5] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1480) + 8) < 0 ? ((iL[2] + 1480) + 8) : ((iL[2] + 1480) + 8) + 0, (long) memory.readLong((int) (iL[5] + 8) < 0 ? (iL[5] + 8) : (iL[5] + 8) + 0)); + iL[6] = 0; + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1480, (long) memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + long[] callArgs_198 = new long[2]; + callArgs_198[1] = ((long) (iL[2] + 1480)); + callArgs_198[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_198); + label_80: while (true) { + label_81: { + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + if (((int) memory.read((int) (iL[3] + (iL[5] * 40)) < 0 ? (iL[3] + (iL[5] * 40)) : (iL[3] + (iL[5] * 40)) + 36) & 0xFF) != 0) { + break label_81; + } + long[] callArgs_199 = new long[2]; + callArgs_199[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + callArgs_199[0] = ((long) (iL[2] + 1520)); + instance.getMachine().call(557, callArgs_199); + iL[5] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[7] = (iL[3] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) * 40)); + memory.writeLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520)); + memory.writeLong((int) (iL[7] + 8) < 0 ? (iL[7] + 8) : (iL[7] + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0)); + memory.writeLong((int) (iL[7] + 16) < 0 ? (iL[7] + 16) : (iL[7] + 16) + 0, (long) memory.readLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0)); + memory.writeLong((int) (iL[7] + 24) < 0 ? (iL[7] + 24) : (iL[7] + 24) + 0, (long) memory.readLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0)); + memory.writeI32((int) (iL[7] + 32) < 0 ? (iL[7] + 32) : (iL[7] + 32) + 0, (int) memory.readInt((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0)); + label_82: { + if (((int) memory.read((int) iL[7] < 0 ? iL[7] : iL[7] + 36) & 0xFF) != 0) { + break label_82; + } + memory.writeByte((int) iL[7] < 0 ? iL[7] : iL[7] + 36, (byte) (1)); + } + if (((int) memory.read((int) (iL[3] + (iL[5] * 40)) < 0 ? (iL[3] + (iL[5] * 40)) : (iL[3] + (iL[5] * 40)) + 36) & 0xFF) != 0) { + break label_81; + } + iL[5] = (iL[5] ^ 1); + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (byte) (iL[5])); + } + iL[5] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + break label_5; + } + memory.writeLong((int) ((iL[2] + 1120) + 8) < 0 ? ((iL[2] + 1120) + 8) : ((iL[2] + 1120) + 8) + 0, (long) memory.readLong((int) (iL[5] + 8) < 0 ? (iL[5] + 8) : (iL[5] + 8) + 0)); + memory.writeI32((int) ((iL[2] + 1120) + 16) < 0 ? ((iL[2] + 1120) + 16) : ((iL[2] + 1120) + 16) + 0, (int) memory.readInt((int) (iL[5] + 16) < 0 ? (iL[5] + 16) : (iL[5] + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1120, (long) memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + long[] callArgs_200 = new long[3]; + callArgs_200[2] = ((long) (iL[2] + 1520)); + callArgs_200[1] = ((long) (iL[2] + 1120)); + callArgs_200[0] = ((long) iL[0]); + long[] callResult_200 = instance.getMachine().call(1294, callArgs_200); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_200[0])) != 0) { + break label_4; + } + memory.writeByte((int) ((iL[2] + 1144) + iL[6]) < 0 ? ((iL[2] + 1144) + iL[6]) : ((iL[2] + 1144) + iL[6]) + 0, (byte) (int) (memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520))); + iL[6] = (iL[6] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(16, iL[6]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_80; + } + break; + } + long[] callArgs_201 = new long[1]; + callArgs_201[0] = ((long) 56); + long[] callResult_201 = instance.getMachine().call(1776, callArgs_201); + iL[0] = ((int) callResult_201[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 46); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 49468); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) (iL[2] + 1704) < 0 ? (iL[2] + 1704) : (iL[2] + 1704) + 0)); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 36, (int) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 1504)); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 40, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1144)); + memory.writeLong((int) (iL[0] + 48) < 0 ? (iL[0] + 48) : (iL[0] + 48) + 0, (long) memory.readLong((int) ((iL[2] + 1144) + 8) < 0 ? ((iL[2] + 1144) + 8) : ((iL[2] + 1144) + 8) + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_6; + } + int ciTableIdx_202 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_202 = instance.table(0).requiredRef(ciTableIdx_202); + com.dylibso.chicory.runtime.Instance ciRefInstance_202 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_202), instance); + if (!ciRefInstance_202.type(ciRefInstance_202.functionType(ciFuncId_202)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_202 = new long[1]; + callArgs_202[0] = ((long) iL[3]); + ciRefInstance_202.getMachine().call(ciFuncId_202, callArgs_202); + } + iL[5] = 0; + break label_3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + iL[5] = 1; + } + instance.global(0).setValue(((long) (iL[2] + 1712))); + return iL[5]; + } + + public static long[] call_1176(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1176(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1177(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = 0; + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + local5 = ((int) callResult_1[0]); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, local4) != 0) { + break label_1; + } + label_2: { + label_3: while (true) { + label_4: { + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1156, callArgs_2); + if (((int) callResult_2[0]) != 0) { + break label_4; + } + local3 = 0; + label_5: { + switch((local5 + -90)) { + case 0: + { + break label_4; + } + case 1: + { + break label_2; + } + case 2: + { + break label_2; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_4; + } + case 6: + { + break label_2; + } + case 7: + { + break label_2; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_2; + } + case 19: + { + break label_2; + } + case 20: + { + break label_2; + } + case 21: + { + break label_2; + } + case 22: + { + break label_2; + } + case 23: + { + break label_2; + } + case 24: + { + break label_2; + } + case 25: + { + break label_2; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_2; + } + case 29: + { + break label_2; + } + case 30: + { + break label_2; + } + case 31: + { + break label_2; + } + case 32: + { + break label_2; + } + case 33: + { + break label_2; + } + case 34: + { + break label_2; + } + case 35: + { + break label_2; + } + case 36: + { + break label_2; + } + case 37: + { + break label_4; + } + case 38: + { + break label_4; + } + default: + { + break label_5; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(68, local5) != 0) { + break label_2; + } + } + label_6: { + label_7: { + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local2); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1174, callArgs_3); + if (((int) callResult_3[0]) != 0) { + break label_7; + } + local6 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_6; + } + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + local8 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + local5 = local6; + label_8: while (true) { + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + label_9: { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local2 < 0 ? local2 : local2 + 4), local6) != 0) { + break label_10; + } + local9 = local4; + local3 = local4; + label_11: { + local10 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_11; + } + memory.writeI32((int) local10 < 0 ? local10 : local10 + 4, (int) local4); + local3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local9 = local6; + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_12; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local10); + local6 = local9; + break label_9; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local10); + local6 = local9; + break label_9; + } + local6 = 0; + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) 0); + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 4, (long) 0L); + local3 = arg1; + label_13: { + local9 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_13; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local9); + local3 = (local9 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local5); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local5); + local8 = (local8 + -1); + local7 = (local7 + 1); + local5 = local4; + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local6); + break label_6; + } + local3 = 1; + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 666); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1161, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_2; + } + } + local3 = 0; + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 0); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + local4 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + local5 = ((int) callResult_6[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(30, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + label_14: while (true) { + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + int ciTableIdx_7 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local5); + ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + local5 = local4; + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_1177(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1177(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1178(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + long local5 = 0L; + long local6 = 0L; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + label_4: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_0[0])) != 0) { + break label_4; + } + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = ((arg0 + 16) + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + local5 = memory.readLong((int) local4 < 0 ? local4 : local4 + 24); + local6 = (local5 >>> 32L); + arg0 = (int) local6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, 2147483632) != 0) { + break label_1; + } + local3 = (int) local5; + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 10) != 0) { + break label_6; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 11, (byte) (int) (local6)); + local4 = local2; + break label_5; + } + local7 = ((arg0 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local7); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local4 = ((int) callResult_1[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) (local7 | -2147483648)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) arg0); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg0); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + arg0) < 0 ? (((int) callResult_2[0]) + arg0) : (((int) callResult_2[0]) + arg0) + 0, (byte) (0)); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_7; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_3); + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + break label_3; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_8; + } + memory.writeByte((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 0, (byte) (0)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) 0); + break label_3; + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 11, (byte) (0)); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (0)); + } + instance.global(0).setValue(((long) (local2 + 16))); + return 0; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1178(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1178(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1179(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + long local7 = 0L; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 12)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1180, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_2; + } + local3 = 1; + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 116)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1175, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_2; + } + label_3: { + local4 = (arg0 + 16); + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_2[0] = ((long) (local2 + 8)); + instance.getMachine().call(557, callArgs_2); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 8) + 24) < 0 ? ((local2 + 8) + 24) : ((local2 + 8) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 8) + 32) < 0 ? ((local2 + 8) + 32) : ((local2 + 8) + 32) + 0)); + label_4: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_4; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + local3 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + } + arg0 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 36) & 0xFF)) != 0) { + break label_1; + } + local6 = memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + local7 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) (arg1 + 144) < 0 ? (arg1 + 144) : (arg1 + 144) + 0, (int) memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0)); + memory.writeLong((int) (arg1 + 136) < 0 ? (arg1 + 136) : (arg1 + 136) + 0, (long) local6); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 128, (long) local7); + local3 = 0; + } + instance.global(0).setValue(((long) (local2 + 48))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1179(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1179(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1180(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 8, (byte) (0)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) ((local2 + 8) | 4)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeLong((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0, (long) 0L); + local4 = (local2 + 72); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeLong((int) (local2 + 64) < 0 ? (local2 + 64) : (local2 + 64) + 0, (long) 0L); + memory.writeLong((int) (local2 + 56) < 0 ? (local2 + 56) : (local2 + 56) + 0, (long) 0L); + local5 = (local2 + 92); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeI32((int) (local2 + 88) < 0 ? (local2 + 88) : (local2 + 88) + 0, (int) 1065353216); + memory.writeLong((int) (local2 + 100) < 0 ? (local2 + 100) : (local2 + 100) + 0, (long) 0L); + memory.writeI32((int) (local2 + 108) < 0 ? (local2 + 108) : (local2 + 108) + 0, (int) 1065353216); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) 0L); + local6 = 1; + local7 = (local2 + 48); + label_1: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1232, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + local6 = 1; + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local4); + callArgs_2[2] = ((long) local7); + callArgs_2[1] = ((long) 39); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1238, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_1; + } + local6 = 1; + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local5); + callArgs_3[2] = ((long) (local2 + 60)); + callArgs_3[1] = ((long) 43); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1238, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_1; + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (((int) memory.read((int) local2 < 0 ? local2 : local2 + 8) & 0xFF))); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) (arg1 + 4)); + long[] callResult_4 = instance.getMachine().call(160, callArgs_4); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, (local2 + 8)) != 0) { + break label_2; + } + local6 = 0; + break label_1; + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) memory.readInt((int) (local2 + 52) < 0 ? (local2 + 52) : (local2 + 52) + 0)); + callArgs_5[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 48)); + callArgs_5[0] = ((long) (arg1 + 40)); + instance.getMachine().call(344, callArgs_5); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) memory.readInt((int) (local2 + 64) < 0 ? (local2 + 64) : (local2 + 64) + 0)); + callArgs_6[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 60)); + callArgs_6[0] = ((long) (arg1 + 52)); + instance.getMachine().call(344, callArgs_6); + memory.writeF32((int) (arg1 + 80) < 0 ? (arg1 + 80) : (arg1 + 80) + 0, (float) memory.readFloat((int) local2 < 0 ? local2 : local2 + 88)); + local6 = 0; + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) memory.readInt((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0)); + callArgs_7[0] = ((long) (arg1 + 64)); + instance.getMachine().call(1304, callArgs_7); + memory.writeF32((int) (arg1 + 100) < 0 ? (arg1 + 100) : (arg1 + 100) + 0, (float) memory.readFloat((int) local2 < 0 ? local2 : local2 + 108)); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 0); + callArgs_8[1] = ((long) memory.readInt((int) (local2 + 100) < 0 ? (local2 + 100) : (local2 + 100) + 0)); + callArgs_8[0] = ((long) (arg1 + 84)); + instance.getMachine().call(1304, callArgs_8); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local7); + long[] callResult_9 = instance.getMachine().call(1305, callArgs_9); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local3); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + instance.global(0).setValue(((long) (local2 + 112))); + return local6; + } + + public static long[] call_1180(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1180(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1181(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 16); + local4 = (local2 + 88); + local5 = ((local2 + 32) + 20); + local6 = 0; + label_1: { + label_2: while (true) { + label_3: { + local7 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + if (((int) memory.read((int) (local3 + (local7 * 40)) < 0 ? (local3 + (local7 * 40)) : (local3 + (local7 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_0[0] = ((long) (local2 + 104)); + instance.getMachine().call(557, callArgs_0); + local7 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local8 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) * 40)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (long) memory.readLong((int) ((local2 + 104) + 8) < 0 ? ((local2 + 104) + 8) : ((local2 + 104) + 8) + 0)); + memory.writeLong((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0, (long) memory.readLong((int) ((local2 + 104) + 16) < 0 ? ((local2 + 104) + 16) : ((local2 + 104) + 16) + 0)); + memory.writeLong((int) (local8 + 24) < 0 ? (local8 + 24) : (local8 + 24) + 0, (long) memory.readLong((int) ((local2 + 104) + 24) < 0 ? ((local2 + 104) + 24) : ((local2 + 104) + 24) + 0)); + memory.writeI32((int) (local8 + 32) < 0 ? (local8 + 32) : (local8 + 32) + 0, (int) memory.readInt((int) ((local2 + 104) + 32) < 0 ? ((local2 + 104) + 32) : ((local2 + 104) + 32) + 0)); + label_4: { + if (((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF) != 0) { + break label_4; + } + memory.writeByte((int) local8 < 0 ? local8 : local8 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local7 * 40)) < 0 ? (local3 + (local7 * 40)) : (local3 + (local7 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + local7 = (local7 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local7)); + } + local7 = (local3 + (local7 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local7 < 0 ? local7 : local7 + 36) & 0xFF)) != 0) { + break label_1; + } + local9 = ((local2 + 32) + 8); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) memory.readLong((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0)); + local10 = ((local2 + 32) + 16); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) memory.readInt((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + local11 = ((int) callResult_1[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 88, (long) 0L); + local8 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local7 = (local3 + (local8 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local7 < 0 ? local7 : local7 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local8 ^ 1))); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 36, (byte) (0)); + label_5: { + label_6: { + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(76, memory.readInt((int) local7 < 0 ? local7 : local7 + 20)) != 0) { + break label_8; + } + local12 = 0; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local11); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1166, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_6; + } + break label_7; + } + local8 = (local6 & 1); + local6 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_7; + } + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + local12 = 0; + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) 0); + callArgs_3[2] = ((long) 18326); + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_3); + local6 = 1; + break label_6; + } + local12 = 0; + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1173, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_6; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 44); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1160, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_6; + } + label_9: { + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)) != 0) { + break label_9; + } + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 32)); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) memory.readInt((int) local10 < 0 ? local10 : local10 + 0)); + memory.writeLong((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0, (long) memory.readLong((int) local9 < 0 ? local9 : local9 + 0)); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local11); + callArgs_6[0] = ((long) (local7 + 20)); + long[] callResult_6 = instance.getMachine().call(157, callArgs_6); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (local7 + 68)); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 56, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeI32((int) (local7 + 64) < 0 ? (local7 + 64) : (local7 + 64) + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 96)); + local12 = 1; + break label_5; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) (local2 + 32)); + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(1303, callArgs_7); + local12 = 1; + } + local7 = memory.readInt((int) local2 < 0 ? local2 : local2 + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_5; + } + label_10: while (true) { + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + int ciTableIdx_8 = (int) (memory.readInt((int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0) < 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 0) : memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 4)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local7); + ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + local7 = local8; + if (local8 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 88, (long) 0L); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local11); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + label_11: { + label_12: { + if (local12 != 0) { + break label_12; + } + local7 = 1; + break label_11; + } + local7 = 0; + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) 0); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1154, callArgs_10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_10[0])) != 0) { + break label_11; + } + local8 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local11 = (local3 + (local8 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local11 < 0 ? local11 : local11 + 36) & 0xFF)) != 0) { + break label_1; + } + local7 = 0; + memory.writeByte((int) (local11 + 36) < 0 ? (local11 + 36) : (local11 + 36) + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local8 ^ 1))); + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 0); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1154, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(76, (((int) callResult_11[0]) & -2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + } + break; + } + instance.global(0).setValue(((long) (local2 + 144))); + return local7; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1181(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1181(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1182(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + local3 = 0; + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + local5 = ((int) callResult_1[0]); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, local4) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(76, (local5 & -4)) != 0) { + break label_1; + } + local4 = (arg0 + 16); + local6 = (local2 + 64); + local7 = (local2 + 28); + label_2: { + label_3: { + label_4: while (true) { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local8 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF)) != 0) { + break label_3; + } + memory.writeByte((int) (local8 + 36) < 0 ? (local8 + 36) : (local8 + 36) + 0, (byte) (0)); + local5 = (local5 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + label_5: { + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_5; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_2[0] = ((long) (local2 + 104)); + instance.getMachine().call(557, callArgs_2); + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local8 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) * 40)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (long) memory.readLong((int) ((local2 + 104) + 8) < 0 ? ((local2 + 104) + 8) : ((local2 + 104) + 8) + 0)); + memory.writeLong((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0, (long) memory.readLong((int) ((local2 + 104) + 16) < 0 ? ((local2 + 104) + 16) : ((local2 + 104) + 16) + 0)); + memory.writeLong((int) (local8 + 24) < 0 ? (local8 + 24) : (local8 + 24) + 0, (long) memory.readLong((int) ((local2 + 104) + 24) < 0 ? ((local2 + 104) + 24) : ((local2 + 104) + 24) + 0)); + memory.writeI32((int) (local8 + 32) < 0 ? (local8 + 32) : (local8 + 32) + 0, (int) memory.readInt((int) ((local2 + 104) + 32) < 0 ? ((local2 + 104) + 32) : ((local2 + 104) + 32) + 0)); + label_6: { + if (((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF) != 0) { + break label_6; + } + memory.writeByte((int) local8 < 0 ? local8 : local8 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_5; + } + local5 = (local5 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + } + local5 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_3; + } + local9 = ((local2 + 8) + 8); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) memory.readLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + local10 = ((local2 + 8) + 16); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) memory.readInt((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local7); + long[] callResult_3 = instance.getMachine().call(154, callArgs_3); + local3 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(154, callArgs_4); + local8 = ((int) callResult_4[0]); + local11 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local4 + (local11 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local11 ^ 1))); + local11 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (0)); + local12 = 2; + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + switch((memory.readInt((int) local5 < 0 ? local5 : local5 + 20) + -76)) { + case 0: + { + break label_10; + } + case 1: + { + break label_8; + } + case 2: + { + break label_11; + } + case 3: + { + break label_9; + } + default: + { + break label_12; + } + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local11 = 1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 100, (int) local11); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local3); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1166, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_6[0])) != 0) { + break label_7; + } + break label_2; + } + local12 = 3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 100, (int) local12); + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local8); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1166, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_7[0])) != 0) { + break label_2; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) 44); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1160, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_8[0])) != 0) { + break label_2; + } + label_13: { + label_14: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)) != 0) { + break label_14; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + memory.writeI32((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (int) memory.readInt((int) local10 < 0 ? local10 : local10 + 0)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) local9 < 0 ? local9 : local9 + 0)); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local3); + callArgs_9[0] = ((long) (local5 + 20)); + long[] callResult_9 = instance.getMachine().call(157, callArgs_9); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) local8); + callArgs_10[0] = ((long) (local5 + 56)); + long[] callResult_10 = instance.getMachine().call(157, callArgs_10); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (local5 + 96)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 92, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 100)); + break label_13; + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) (local2 + 8)); + callArgs_11[0] = ((long) arg1); + instance.getMachine().call(1306, callArgs_11); + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local8); + long[] callResult_12 = instance.getMachine().call(162, callArgs_12); + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local3); + long[] callResult_13 = instance.getMachine().call(162, callArgs_13); + local3 = 0; + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) 0); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(1154, callArgs_14); + local5 = ((int) callResult_14[0]); + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) 1); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1154, callArgs_15); + local8 = ((int) callResult_15[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, local5) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(76, (local8 & -4)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break label_1; + } + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local8); + long[] callResult_17 = instance.getMachine().call(162, callArgs_17); + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) local3); + long[] callResult_18 = instance.getMachine().call(162, callArgs_18); + local3 = 1; + } + instance.global(0).setValue(((long) (local2 + 144))); + return local3; + } + + public static long[] call_1182(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1182(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1183(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[18]; + long[] lL = new long[1]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) iL[2])); + iL[3] = 0; + label_1: { + label_2: { + label_3: { + label_4: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) iL[0]); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(135, ((int) callResult_0[0])) != 0) { + break label_4; + } + iL[4] = (iL[0] + 16); + iL[5] = 0; + iL[6] = 0; + iL[7] = 0; + label_5: while (true) { + iL[8] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[9] = (iL[4] + (iL[8] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 36) & 0xFF)) != 0) { + break label_3; + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[8] ^ 1))); + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 36, (byte) (0)); + lL[0] = memory.readLong((int) iL[9] < 0 ? iL[9] : iL[9] + 24); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[6], iL[5]) != 0) { + break label_7; + } + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) lL[0]); + iL[6] = (iL[6] + 8); + break label_6; + } + iL[8] = ((iL[6] - iL[7]) >> 3); + iL[9] = (iL[8] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], 536870912) != 0) { + break label_2; + } + label_8: { + label_9: { + iL[5] = (iL[5] - iL[7]); + iL[10] = (iL[5] >>> 2); + iL[9] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[5], 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[10], iL[9]) != 0 ? iL[10] : iL[9]) : 536870911); + if (iL[9] != 0) { + break label_9; + } + iL[5] = 0; + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], 536870912) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (iL[9] << 3)); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + iL[5] = ((int) callResult_1[0]); + } + iL[8] = (iL[5] + (iL[8] << 3)); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (long) lL[0]); + iL[11] = (iL[9] << 3); + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[7], iL[6]) != 0) { + break label_11; + } + iL[10] = iL[6]; + iL[7] = iL[8]; + break label_10; + } + iL[9] = iL[8]; + label_12: while (true) { + iL[9] = (iL[9] + -8); + iL[6] = (iL[6] + -8); + memory.writeLong((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[7], iL[6]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break; + } + iL[10] = iL[7]; + iL[7] = iL[9]; + } + iL[5] = (iL[5] + iL[11]); + iL[6] = (iL[8] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[10]) != 0) { + break label_6; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) iL[10]); + instance.getMachine().call(1777, callArgs_2); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) iL[0]); + long[] callResult_3 = instance.getMachine().call(1154, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(135, ((int) callResult_3[0])) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + label_13: { + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[6], iL[7]) != 0) { + break label_14; + } + iL[3] = 0; + break label_13; + } + iL[3] = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[6], iL[7]); + iL[12] = iL[7]; + label_15: while (true) { + label_16: { + lL[0] = memory.readLong((int) iL[12] < 0 ? iL[12] : iL[12] + 0); + iL[9] = (int) (lL[0] >>> 32L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[9], 3) != 0) { + break label_16; + } + iL[0] = (iL[9] + -1); + iL[9] = (iL[9] + -2); + iL[9] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], iL[9]) != 0 ? iL[0] : iL[9]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[9], 1) != 0) { + break label_16; + } + iL[0] = (int) lL[0]; + iL[11] = ((iL[9] + iL[0]) + 1); + iL[10] = (iL[0] + 1); + label_17: while (true) { + label_18: { + label_19: { + int _d0 = func_1183__h0(iL, lL, memory, instance); + if (_d0 == 1) + break label_18; + if (_d0 == 2) + break label_2; + } + label_163: { + label_164: { + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[0]) != 0) { + break label_164; + } + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (byte) (iL[5])); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[9] + 1)); + break label_163; + } + iL[8] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[13] = (iL[9] - iL[8]); + iL[4] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[4], -1) != 0) { + break label_2; + } + label_165: { + label_166: { + iL[0] = (iL[0] - iL[8]); + iL[14] = (iL[0] << 1); + iL[14] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[14], iL[4]) != 0 ? iL[14] : iL[4]) : 2147483647); + if (iL[14] != 0) { + break label_166; + } + iL[4] = 0; + break label_165; + } + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) iL[14]); + long[] callResult_35 = instance.getMachine().call(1776, callArgs_35); + iL[4] = ((int) callResult_35[0]); + } + iL[0] = (iL[4] + iL[13]); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (iL[5])); + iL[14] = (iL[4] + iL[14]); + iL[15] = (iL[0] + 1); + label_167: { + label_168: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[9]) != 0) { + break label_168; + } + iL[4] = iL[0]; + break label_167; + } + iL[16] = ((iL[8] ^ -1) + iL[9]); + label_169: { + iL[5] = (iL[13] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_169; + } + label_170: while (true) { + iL[0] = (iL[0] + -1); + iL[9] = (iL[9] + -1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_170; + } + break; + } + } + label_171: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], 3) != 0) { + break label_171; + } + iL[0] = (iL[0] + -4); + label_172: while (true) { + memory.writeByte((int) (iL[0] + 3) < 0 ? (iL[0] + 3) : (iL[0] + 3) + 0, (byte) (((int) memory.read((int) (iL[9] + -1) < 0 ? (iL[9] + -1) : (iL[9] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 2) < 0 ? (iL[0] + 2) : (iL[0] + 2) + 0, (byte) (((int) memory.read((int) (iL[9] + -2) < 0 ? (iL[9] + -2) : (iL[9] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 1) < 0 ? (iL[0] + 1) : (iL[0] + 1) + 0, (byte) (((int) memory.read((int) (iL[9] + -3) < 0 ? (iL[9] + -3) : (iL[9] + -3) + 0) & 0xFF))); + iL[9] = (iL[9] + -4); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_172; + } + break; + } + } + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[14]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + break label_163; + } + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) iL[9]); + instance.getMachine().call(1777, callArgs_36); + } + iL[8] = iL[10]; + } + iL[10] = (iL[8] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[10], iL[11]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_17; + } + break; + } + } + iL[12] = (iL[12] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[6], iL[12]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_15; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[7]) != 0) { + break label_4; + } + long[] callArgs_37 = new long[1]; + callArgs_37[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_37); + } + instance.global(0).setValue(((long) (iL[2] + 16))); + return iL[3]; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1183(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1183(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1184(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local2 + 72)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local3 = ((int) callResult_0[0]); + label_1: { + label_2: while (true) { + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local2 + 32)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + local4 = ((int) callResult_1[0]); + label_3: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1154, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(59, ((int) callResult_2[0])) != 0) { + break label_3; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1154, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_3[0])) != 0) { + break label_1; + } + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1166, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + label_4: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)) != 0) { + break label_4; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local3); + callArgs_6[0] = ((long) local4); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (((int) callResult_6[0]) + 36)); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local3); + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(1185, callArgs_7); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local4); + callArgs_8[0] = ((long) local3); + long[] callResult_8 = instance.getMachine().call(160, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + local4 = 0; + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4), memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0) { + break label_5; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 11, (byte) (5)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 5, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 11776)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 4, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 11780) & 0xFF))); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) 12); + long[] callResult_10 = instance.getMachine().call(1776, callArgs_10); + arg1 = ((int) callResult_10[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + local4 = (arg1 + 12); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) local4); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) 12204); + callArgs_11[1] = ((long) (local2 + 16)); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1163, callArgs_11); + local4 = ((int) callResult_11[0]); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_6; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_12); + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 11), -1) != 0) { + break label_5; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_14); + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local3); + long[] callResult_15 = instance.getMachine().call(162, callArgs_15); + instance.global(0).setValue(((long) (local2 + 112))); + return local4; + } + + public static long[] call_1184(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1184(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1185(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2), 36); + local4 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 119304648) != 0) { + break label_4; + } + label_5: { + label_6: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 36); + local5 = (local2 << 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, local4) != 0 ? local5 : local4) : 119304647); + if (local4 != 0) { + break label_6; + } + local2 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 119304648) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 * 36)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + } + local5 = (local2 + (local4 * 36)); + local2 = (local2 + (local3 * 36)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + local3 = ((int) callResult_1[0]); + local6 = (local3 + 36); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_2; + } + local2 = (local2 + -36); + label_7: while (true) { + local4 = (local4 + -36); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local4); + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(157, callArgs_2); + local3 = ((int) callResult_2[0]); + local2 = (local2 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_1; + } + local2 = (local2 + -36); + label_8: while (true) { + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + arg1 = ((int) callResult_3[0]); + local2 = (local2 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_9; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_6); + } + return; + } + + public static long[] call_1185(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1185(arg0, arg1, memory, instance); + return null; + } + + public static int func_1186(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_6; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(12, ((int) callResult_1[0])) != 0) { + break label_6; + } + local3 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local5 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_5; + } + local6 = 0; + memory.writeByte((int) (local5 + 36) < 0 ? (local5 + 36) : (local5 + 36) + 0, (byte) (0)); + local5 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + local3 = (local3 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_5; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local2); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1173, callArgs_2); + if (((int) callResult_2[0]) != 0) { + break label_2; + } + local6 = 1; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 44); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1160, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_2; + } + break label_3; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 0); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1154, callArgs_4); + local4 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + local3 = ((int) callResult_5[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, local4) != 0) { + break label_4; + } + label_7: { + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + long[] callResult_6 = instance.getMachine().call(1156, callArgs_6); + if (((int) callResult_6[0]) != 0) { + break label_7; + } + local6 = 0; + label_8: { + switch((local3 + -90)) { + case 0: + { + break label_7; + } + case 1: + { + break label_2; + } + case 2: + { + break label_2; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_7; + } + case 6: + { + break label_2; + } + case 7: + { + break label_2; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_2; + } + case 19: + { + break label_2; + } + case 20: + { + break label_2; + } + case 21: + { + break label_2; + } + case 22: + { + break label_2; + } + case 23: + { + break label_2; + } + case 24: + { + break label_2; + } + case 25: + { + break label_2; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_2; + } + case 29: + { + break label_2; + } + case 30: + { + break label_2; + } + case 31: + { + break label_2; + } + case 32: + { + break label_2; + } + case 33: + { + break label_2; + } + case 34: + { + break label_2; + } + case 35: + { + break label_2; + } + case 36: + { + break label_2; + } + case 37: + { + break label_7; + } + case 38: + { + break label_7; + } + default: + { + break label_8; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(68, local3) != 0) { + break label_4; + } + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local2); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1174, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_7[0])) != 0) { + break label_3; + } + break label_4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local6 = 0; + break label_2; + } + local6 = 0; + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + label_9: { + arg0 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_9; + } + label_10: while (true) { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg0); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + arg0 = local4; + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local4); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 4, (long) 0L); + local6 = 1; + break label_1; + } + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + label_11: while (true) { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg0); + ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + arg0 = local4; + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + } + instance.global(0).setValue(((long) (local2 + 16))); + return local6; + } + + public static long[] call_1186(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1186(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1187(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1186, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_0[0])) != 0) { + break label_1; + } + label_2: while (true) { + label_3: { + label_4: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)) != 0) { + break label_4; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (local3 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 4, (long) 0L); + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local2); + callArgs_1[0] = ((long) arg1); + instance.getMachine().call(1188, callArgs_1); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local2); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1186, callArgs_2); + if (((int) callResult_2[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + arg0 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + label_5: { + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + label_6: while (true) { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + arg1 = local3; + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + instance.global(0).setValue(((long) (local2 + 16))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg0, local4); + } + + public static long[] call_1187(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1187(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1188(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 12); + local5 = (local4 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 357913942) != 0) { + break label_2; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local3), 12); + local7 = (local6 << 1); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, local5) != 0 ? local7 : local5) : 357913941); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 357913942) != 0) { + break label_1; + } + local7 = (local5 * 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local6 = ((int) callResult_0[0]); + local8 = (local4 * 12); + local5 = (local6 + local8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + local9 = memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 4, (long) local9); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + local4 = (local6 + local7); + local7 = (local5 + 12); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_3; + } + arg1 = (local2 + -12); + local5 = ((local6 + local8) + -12); + label_4: while (true) { + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + memory.writeLong((int) (arg1 + 4) < 0 ? (arg1 + 4) : (arg1 + 4) + 0, (long) 0L); + local5 = (local5 + -12); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg1); + arg1 = (arg1 + -12); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local5 = (local5 + 12); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local4); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local7); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local3) != 0) { + break label_5; + } + label_6: while (true) { + label_7: { + local2 = (local3 + -12); + arg1 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_7; + } + label_8: while (true) { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg1); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + arg1 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + memory.writeLong((int) (local3 + -8) < 0 ? (local3 + -8) : (local3 + -8) + 0, (long) 0L); + local3 = local2; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_9; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_2); + } + return; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1188(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1188(arg0, arg1, memory, instance); + return null; + } + + public static void func_1189(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)) != 0) { + break label_1; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + 12)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 4, (long) 0L); + return; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1188, callArgs_0); + return; + } + + public static long[] call_1189(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1189(arg0, arg1, memory, instance); + return null; + } + + public static int func_1190(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local2 + 56)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local3 = ((int) callResult_0[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) 0L); + label_1: { + label_2: while (true) { + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + local4 = ((int) callResult_1[0]); + label_3: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1154, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(59, ((int) callResult_2[0])) != 0) { + break label_3; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1154, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_3[0])) != 0) { + break label_1; + } + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1166, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) 72); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + local4 = ((int) callResult_6[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 49596); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) 0L); + memory.writeLong((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (long) 0L); + memory.writeLong((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (long) 154618822656L); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local3); + callArgs_7[0] = ((long) (local4 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + label_4: { + label_5: { + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 44); + if (local5 != 0) { + break label_5; + } + local5 = (local2 + 40); + break label_4; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local5); + local5 = (local5 + 4); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 44, (int) local4); + local6 = (memory.readInt((int) local2 < 0 ? local2 : local2 + 48) + 1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) local6); + label_6: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)) != 0) { + break label_6; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 40)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (local5 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 44, (long) 0L); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) (local2 + 40)); + callArgs_8[0] = ((long) arg1); + instance.getMachine().call(1188, callArgs_8); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local4); + callArgs_9[0] = ((long) local3); + long[] callResult_9 = instance.getMachine().call(160, callArgs_9); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local4); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + arg0 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + label_7: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_7; + } + label_8: while (true) { + arg1 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + int ciTableIdx_11 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_11 = instance.table(0).requiredRef(ciTableIdx_11); + com.dylibso.chicory.runtime.Instance ciRefInstance_11 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_11), instance); + if (!ciRefInstance_11.type(ciRefInstance_11.functionType(ciFuncId_11)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local4); + ciRefInstance_11.getMachine().call(ciFuncId_11, callArgs_11); + local4 = arg1; + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local3); + long[] callResult_12 = instance.getMachine().call(162, callArgs_12); + instance.global(0).setValue(((long) (local2 + 96))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, arg0); + } + + public static long[] call_1190(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1190(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1191(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 192); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (((int) memory.read((int) local3 < 0 ? local3 : local3 + 6) & 0xFF) != 0) { + break label_2; + } + if (((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF) != 0) { + break label_2; + } + local3 = 0; + break label_1; + } + local3 = 0; + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_1; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(40, ((int) callResult_1[0])); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1154, callArgs_2); + local4 = ((int) callResult_2[0]); + label_3: { + label_4: { + if (local3 != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(137, local4) != 0) { + break label_4; + } + memory.writeByte((int) (local2 + 110) < 0 ? (local2 + 110) : (local2 + 110) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 27820) & 0xFF))); + memory.writeByte((int) (local2 + 122) < 0 ? (local2 + 122) : (local2 + 122) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 28188) & 0xFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 107, (byte) (3)); + memory.writeShort((int) local2 < 0 ? local2 : local2 + 96, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 28150) & 0xFFFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 98, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 28152) & 0xFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 119, (byte) (3)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 99, (byte) (0)); + memory.writeShort((int) local2 < 0 ? local2 : local2 + 108, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 27818) & 0xFFFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 131, (byte) (3)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 111, (byte) (0)); + memory.writeShort((int) local2 < 0 ? local2 : local2 + 120, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 28186) & 0xFFFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 143, (byte) (3)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 123, (byte) (0)); + memory.writeByte((int) (local2 + 148) < 0 ? (local2 + 148) : (local2 + 148) + 0, (byte) (0)); + memory.writeByte((int) (local2 + 134) < 0 ? (local2 + 134) : (local2 + 134) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 27855) & 0xFF))); + local4 = ((local2 + 96) + 68); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 14827) & 0xFF))); + memory.writeShort((int) (local2 + 172) < 0 ? (local2 + 172) : (local2 + 172) + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 14816) & 0xFFFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 155, (byte) (4)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 135, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 144, (int) 942813558); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 167, (byte) (9)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 179, (byte) (6)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 165, (byte) (0)); + memory.writeShort((int) local2 < 0 ? local2 : local2 + 132, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 27853) & 0xFFFF))); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 156, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 14819)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 168, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 14812)); + memory.writeI32((int) (local2 + 183) < 0 ? (local2 + 183) : (local2 + 183) + 0, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 14832)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 191, (byte) (7)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 174, (byte) (0)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 187, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 180, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 14829)); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 96); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local3 = ((int) callResult_3[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 96)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) ((local2 + 96) + 8) < 0 ? ((local2 + 96) + 8) : ((local2 + 96) + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 108)); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) memory.readInt((int) ((local2 + 96) + 20) < 0 ? ((local2 + 96) + 20) : ((local2 + 96) + 20) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 120)); + memory.writeI32((int) (local3 + 32) < 0 ? (local3 + 32) : (local3 + 32) + 0, (int) memory.readInt((int) ((local2 + 96) + 32) < 0 ? ((local2 + 96) + 32) : ((local2 + 96) + 32) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 36, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 132)); + memory.writeI32((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (int) memory.readInt((int) ((local2 + 96) + 44) < 0 ? ((local2 + 96) + 44) : ((local2 + 96) + 44) + 0)); + memory.writeI32((int) (local3 + 56) < 0 ? (local3 + 56) : (local3 + 56) + 0, (int) memory.readInt((int) ((local2 + 96) + 56) < 0 ? ((local2 + 96) + 56) : ((local2 + 96) + 56) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 144)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) local3); + arg1 = (local3 + 96); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) arg1); + memory.writeI32((int) (local3 + 68) < 0 ? (local3 + 68) : (local3 + 68) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 60, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 156)); + memory.writeI32((int) (local3 + 80) < 0 ? (local3 + 80) : (local3 + 80) + 0, (int) memory.readInt((int) ((local2 + 96) + 80) < 0 ? ((local2 + 96) + 80) : ((local2 + 96) + 80) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 72, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 168)); + memory.writeI32((int) (local3 + 92) < 0 ? (local3 + 92) : (local3 + 92) + 0, (int) memory.readInt((int) ((local2 + 96) + 92) < 0 ? ((local2 + 96) + 92) : ((local2 + 96) + 92) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 84, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 180)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 44, (int) arg1); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) (local2 + 40)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1163, callArgs_4); + local4 = ((int) callResult_4[0]); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 95), -1) != 0) { + break label_5; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 84)); + instance.getMachine().call(1777, callArgs_5); + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 83), -1) != 0) { + break label_6; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 72)); + instance.getMachine().call(1777, callArgs_6); + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 71), -1) != 0) { + break label_7; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 60)); + instance.getMachine().call(1777, callArgs_7); + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 59), -1) != 0) { + break label_8; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 48)); + instance.getMachine().call(1777, callArgs_8); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 47), -1) != 0) { + break label_9; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 36)); + instance.getMachine().call(1777, callArgs_9); + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 35), -1) != 0) { + break label_10; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 24)); + instance.getMachine().call(1777, callArgs_10); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 23), -1) != 0) { + break label_11; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 12)); + instance.getMachine().call(1777, callArgs_11); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), -1) != 0) { + break label_12; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_12); + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_13); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 191), -1) != 0) { + break label_13; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 180)); + instance.getMachine().call(1777, callArgs_14); + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 179), -1) != 0) { + break label_14; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 168)); + instance.getMachine().call(1777, callArgs_15); + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 167), -1) != 0) { + break label_15; + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 156)); + instance.getMachine().call(1777, callArgs_16); + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 155), -1) != 0) { + break label_16; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 144)); + instance.getMachine().call(1777, callArgs_17); + } + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 143), -1) != 0) { + break label_17; + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 132)); + instance.getMachine().call(1777, callArgs_18); + } + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 131), -1) != 0) { + break label_18; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 120)); + instance.getMachine().call(1777, callArgs_19); + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 119), -1) != 0) { + break label_19; + } + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 108)); + instance.getMachine().call(1777, callArgs_20); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 107), -1) != 0) { + break label_3; + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 96)); + instance.getMachine().call(1777, callArgs_21); + break label_3; + } + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_20; + } + local4 = 1; + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) 30); + callArgs_22[0] = ((long) arg0); + long[] callResult_22 = instance.getMachine().call(1160, callArgs_22); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_22[0])) != 0) { + break label_3; + } + local4 = 1; + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) 40); + callArgs_23[0] = ((long) arg0); + long[] callResult_23 = instance.getMachine().call(1160, callArgs_23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_23[0])) != 0) { + break label_3; + } + local4 = 1; + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) arg1); + callArgs_24[0] = ((long) arg0); + long[] callResult_24 = instance.getMachine().call(1166, callArgs_24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_24[0])) != 0) { + break label_3; + } + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) 44); + callArgs_25[0] = ((long) arg0); + long[] callResult_25 = instance.getMachine().call(1160, callArgs_25); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_25[0])); + break label_3; + } + label_21: { + label_22: { + local5 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local3 = (local5 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_22; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 36, (byte) (0)); + local6 = memory.readLong((int) local3 < 0 ? local3 : local3 + 24); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 88, (long) local6); + label_23: { + label_24: { + label_25: { + label_26: { + local7 = (int) local6; + switch((local7 + 23)) { + case 0: + { + break label_26; + } + case 1: + { + break label_23; + } + case 2: + { + break label_23; + } + case 3: + { + break label_23; + } + case 4: + { + break label_23; + } + case 5: + { + break label_23; + } + case 6: + { + break label_24; + } + case 7: + { + break label_24; + } + case 8: + { + break label_23; + } + case 9: + { + break label_23; + } + case 10: + { + break label_23; + } + case 11: + { + break label_23; + } + case 12: + { + break label_23; + } + case 13: + { + break label_23; + } + case 14: + { + break label_23; + } + case 15: + { + break label_23; + } + case 16: + { + break label_23; + } + case 17: + { + break label_23; + } + case 18: + { + break label_25; + } + default: + { + break label_23; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 0) & 0xFF)) != 0) { + break label_21; + } + break label_23; + } + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 4) & 0xFF) != 0) { + break label_23; + } + break label_21; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 10) & 0xFF)) != 0) { + break label_21; + } + } + label_27: { + if (((int) memory.read((int) (local5 + (local4 * 40)) < 0 ? (local5 + (local4 * 40)) : (local5 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_27; + } + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_26[0] = ((long) (local2 + 96)); + instance.getMachine().call(557, callArgs_26); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local3 = (local5 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 96)); + memory.writeLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (long) memory.readLong((int) ((local2 + 96) + 8) < 0 ? ((local2 + 96) + 8) : ((local2 + 96) + 8) + 0)); + memory.writeLong((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (long) memory.readLong((int) ((local2 + 96) + 16) < 0 ? ((local2 + 96) + 16) : ((local2 + 96) + 16) + 0)); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) memory.readLong((int) ((local2 + 96) + 24) < 0 ? ((local2 + 96) + 24) : ((local2 + 96) + 24) + 0)); + memory.writeI32((int) (local3 + 32) < 0 ? (local3 + 32) : (local3 + 32) + 0, (int) memory.readInt((int) ((local2 + 96) + 32) < 0 ? ((local2 + 96) + 32) : ((local2 + 96) + 32) + 0)); + label_28: { + if (((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF) != 0) { + break label_28; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local5 + (local4 * 40)) < 0 ? (local5 + (local4 * 40)) : (local5 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_27; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + local3 = (local5 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_22; + } + memory.writeLong((int) ((local2 + 40) + 8) < 0 ? ((local2 + 40) + 8) : ((local2 + 40) + 8) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeI32((int) ((local2 + 40) + 16) < 0 ? ((local2 + 40) + 16) : ((local2 + 40) + 16) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + long[] callArgs_27 = new long[3]; + callArgs_27[2] = ((long) (local2 + 40)); + callArgs_27[1] = ((long) local7); + callArgs_27[0] = ((long) (local2 + 96)); + long[] callResult_27 = instance.getMachine().call(155, callArgs_27); + local3 = ((int) callResult_27[0]); + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) local3); + callArgs_28[0] = ((long) arg1); + long[] callResult_28 = instance.getMachine().call(158, callArgs_28); + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) local3); + long[] callResult_29 = instance.getMachine().call(162, callArgs_29); + local4 = 0; + break label_3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local4 = ((local2 + 64) + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + arg1 = ((local2 + 64) + 8); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 64, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) (local2 + 88)); + callArgs_31[0] = ((long) (local2 + 96)); + instance.getMachine().call(38, callArgs_31); + memory.writeLong((int) ((local2 + 16) + 8) < 0 ? ((local2 + 16) + 8) : ((local2 + 16) + 8) + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) ((local2 + 16) + 16) < 0 ? ((local2 + 16) + 16) : ((local2 + 16) + 16) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 16, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 107), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 96) : (local2 + 96))); + long[] callArgs_32 = new long[4]; + callArgs_32[3] = ((long) local2); + callArgs_32[2] = ((long) 11098); + callArgs_32[1] = ((long) (local2 + 16)); + callArgs_32[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_32); + label_29: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 107), -1) != 0) { + break label_29; + } + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 96)); + instance.getMachine().call(1777, callArgs_33); + } + local4 = 1; + } + instance.global(0).setValue(((long) (local2 + 192))); + return local4; + } + + public static long[] call_1191(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1191(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1192(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + local4 = (local3 + 40); + label_1: { + label_2: while (true) { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 6) & 0xFF) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) != 0) { + break label_6; + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_6; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(40, ((int) callResult_1[0])) != 0) { + break label_5; + } + } + local5 = 0; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1154, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(137, ((int) callResult_2[0])) != 0) { + break label_4; + } + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (local3 + 16)); + long[] callResult_3 = instance.getMachine().call(154, callArgs_3); + local6 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local6); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1191, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_4[0])) != 0) { + break label_3; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + local5 = 1; + } + instance.global(0).setValue(((long) (local3 + 64))); + return local5; + } + label_8: { + label_9: { + label_10: { + if (memory.readInt((int) local3 < 0 ? local3 : local3 + 36) != 0) { + break label_10; + } + local7 = memory.readInt((int) local3 < 0 ? local3 : local3 + 40); + label_11: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local8 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local8) != 0) { + break label_11; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local7) | -4294967296L)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (local5 + 8)); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local6); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + local9 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local10 = ((local5 - local9) >> 3); + local11 = (local10 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local11, 536870912) != 0) { + break label_8; + } + label_12: { + label_13: { + local8 = (local8 - local9); + local12 = (local8 >>> 2); + local11 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local12, local11) != 0 ? local12 : local11) : 536870911); + if (local11 != 0) { + break label_13; + } + local12 = 0; + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local11, 536870912) != 0) { + break label_1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) (local11 << 3)); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + local12 = ((int) callResult_7[0]); + } + local8 = (local12 + (local10 << 3)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local7) | -4294967296L)); + local7 = (local12 + (local11 << 3)); + local11 = (local8 + 8); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, local5) != 0) { + break label_14; + } + label_15: while (true) { + local8 = (local8 + -8); + local5 = (local5 + -8); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_15; + } + break; + } + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local7); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local11); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_9; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local6); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 3)); + long[] callArgs_10 = new long[4]; + callArgs_10[3] = ((long) local4); + callArgs_10[2] = ((long) (local3 + 12)); + callArgs_10[1] = ((long) arg2); + callArgs_10[0] = ((long) (local3 + 56)); + instance.getMachine().call(1193, callArgs_10); + label_16: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local8 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, local8) != 0) { + break label_16; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) -21L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (local5 + 8)); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local6); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + local9 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local12 = ((local5 - local9) >> 3); + local7 = (local12 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 536870912) != 0) { + break label_8; + } + label_17: { + label_18: { + local8 = (local8 - local9); + local11 = (local8 >>> 2); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local11, local7) != 0 ? local11 : local7) : 536870911); + if (local7 != 0) { + break label_18; + } + local11 = 0; + break label_17; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 536870912) != 0) { + break label_1; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) (local7 << 3)); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + local11 = ((int) callResult_12[0]); + } + local8 = (local11 + (local12 << 3)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) -21L); + local7 = (local11 + (local7 << 3)); + local11 = (local8 + 8); + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, local5) != 0) { + break label_19; + } + label_20: while (true) { + local8 = (local8 + -8); + local5 = (local5 + -8); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) local7); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local11); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_9; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_13); + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local6); + long[] callResult_14 = instance.getMachine().call(162, callArgs_14); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1192(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1192(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1193(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 24); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg2); + local5 = (local4 + 12); + local6 = (local4 + 8); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg3 < 0 ? arg3 : arg3 + 11), 0) != 0) { + break label_2; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + break label_1; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4)); + callArgs_1[1] = ((long) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0)); + callArgs_1[0] = ((long) local5); + instance.getMachine().call(1647, callArgs_1); + arg2 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + label_3: { + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local6); + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(1412, callArgs_2); + arg3 = ((int) callResult_2[0]); + if (arg3 != 0) { + break label_3; + } + arg3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + label_4: { + label_5: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 1) != 0) { + break label_5; + } + arg3 = ((arg2 + -1) & arg3); + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, arg2) != 0) { + break label_4; + } + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg3, arg2); + } + label_6: { + label_7: { + label_8: { + local5 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + (arg3 << 2)); + arg3 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (arg3 != 0) { + break label_8; + } + arg3 = (arg1 + 8); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) local4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg3); + arg3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_6; + } + arg3 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + label_9: { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 1) != 0) { + break label_10; + } + arg3 = (arg3 & (arg2 + -1)); + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, arg2) != 0) { + break label_9; + } + arg3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg3, arg2); + } + arg3 = (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + (arg3 << 2)); + break label_7; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0)); + } + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) local4); + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 4, (byte) (1)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 12, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12) + 1)); + return; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 4, (byte) (0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg3); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 23), -1) != 0) { + break label_11; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + instance.getMachine().call(1777, callArgs_3); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_4); + return; + } + + public static long[] call_1193(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1193(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_1194(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((((int) callResult_0[0]) + -138), 3) != 0) { + break label_2; + } + memory.writeShort((int) (local2 + 72) < 0 ? (local2 + 72) : (local2 + 72) + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 12293) & 0xFFFF))); + memory.writeByte((int) (local2 + 82) < 0 ? (local2 + 82) : (local2 + 82) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 12253) & 0xFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 79, (byte) (6)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 60, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) 1668183398); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 67, (byte) (4)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 68, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 12289)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 91, (byte) (3)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 74, (byte) (0)); + memory.writeShort((int) local2 < 0 ? local2 : local2 + 80, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 12251) & 0xFFFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 83, (byte) (0)); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 36); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) ((local2 + 56) + 8) < 0 ? ((local2 + 56) + 8) : ((local2 + 56) + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 68)); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) memory.readInt((int) ((local2 + 56) + 20) < 0 ? ((local2 + 56) + 20) : ((local2 + 56) + 20) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 80)); + memory.writeI32((int) (local3 + 32) < 0 ? (local3 + 32) : (local3 + 32) + 0, (int) memory.readInt((int) ((local2 + 56) + 32) < 0 ? ((local2 + 56) + 32) : ((local2 + 56) + 32) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) local3); + local4 = (local3 + 36); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 104, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 100, (int) local4); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) (local2 + 96)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1163, callArgs_2); + local4 = ((int) callResult_2[0]); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 35), -1) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 24)); + instance.getMachine().call(1777, callArgs_3); + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 23), -1) != 0) { + break label_4; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 12)); + instance.getMachine().call(1777, callArgs_4); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), -1) != 0) { + break label_5; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_5); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_6); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 91), -1) != 0) { + break label_6; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 80)); + instance.getMachine().call(1777, callArgs_7); + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 79), -1) != 0) { + break label_7; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 68)); + instance.getMachine().call(1777, callArgs_8); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), -1) != 0) { + break label_1; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 56)); + instance.getMachine().call(1777, callArgs_9); + break label_1; + } + label_8: { + label_9: { + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local3 = ((arg0 + 16) + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_9; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + local4 = 0; + memory.writeByte((int) local3 < 0 ? local3 : local3 + 36, (byte) (0)); + local5 = memory.readLong((int) local3 < 0 ? local3 : local3 + 24); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 96, (long) local5); + label_10: { + label_11: { + label_12: { + switch(((int) local5 + 34)) { + case 0: + { + break label_12; + } + case 1: + { + break label_12; + } + case 2: + { + break label_10; + } + case 3: + { + break label_10; + } + case 4: + { + break label_10; + } + case 5: + { + break label_10; + } + case 6: + { + break label_10; + } + case 7: + { + break label_10; + } + case 8: + { + break label_10; + } + case 9: + { + break label_10; + } + case 10: + { + break label_10; + } + case 11: + { + break label_10; + } + case 12: + { + break label_10; + } + case 13: + { + break label_10; + } + case 14: + { + break label_10; + } + case 15: + { + break label_10; + } + case 16: + { + break label_10; + } + case 17: + { + break label_11; + } + default: + { + break label_10; + } + } + } + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 13) & 0xFF) != 0) { + break label_10; + } + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 10) & 0xFF)) != 0) { + break label_8; + } + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local5); + break label_1; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local4 = ((local2 + 32) + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + arg1 = ((local2 + 32) + 8); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) (local2 + 96)); + callArgs_11[0] = ((long) (local2 + 56)); + instance.getMachine().call(38, callArgs_11); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 32)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 56) : (local2 + 56))); + long[] callArgs_12 = new long[4]; + callArgs_12[3] = ((long) local2); + callArgs_12[2] = ((long) 11098); + callArgs_12[1] = ((long) (local2 + 8)); + callArgs_12[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_12); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), -1) != 0) { + break label_13; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 56)); + instance.getMachine().call(1777, callArgs_13); + } + local4 = 1; + } + instance.global(0).setValue(((long) (local2 + 112))); + return local4; + } + + public static long[] call_1194(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1194(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1195(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + long local5 = 0L; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(137, ((int) callResult_0[0])) != 0) { + break label_3; + } + local3 = ((local2 + 56) + 20); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 14827) & 0xFF))); + memory.writeShort((int) (local2 + 84) < 0 ? (local2 + 84) : (local2 + 84) + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 14816) & 0xFFFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 67, (byte) (7)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 14829)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 59, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 14832)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 79, (byte) (9)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 63, (byte) (0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 68, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 14819)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 91, (byte) (6)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 77, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 14812)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 86, (byte) (0)); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 36); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local4 = ((int) callResult_1[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) ((local2 + 56) + 8) < 0 ? ((local2 + 56) + 8) : ((local2 + 56) + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 68)); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 80)); + memory.writeI32((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (int) memory.readInt((int) ((local2 + 56) + 32) < 0 ? ((local2 + 56) + 32) : ((local2 + 56) + 32) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) local4); + local3 = (local4 + 36); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 104, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 100, (int) local3); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 0); + callArgs_2[1] = ((long) (local2 + 96)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1163, callArgs_2); + local3 = ((int) callResult_2[0]); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 35), -1) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 24)); + instance.getMachine().call(1777, callArgs_3); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 23), -1) != 0) { + break label_5; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 12)); + instance.getMachine().call(1777, callArgs_4); + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_6; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_5); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_6); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 91), -1) != 0) { + break label_7; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 80)); + instance.getMachine().call(1777, callArgs_7); + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 79), -1) != 0) { + break label_8; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 68)); + instance.getMachine().call(1777, callArgs_8); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), -1) != 0) { + break label_2; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 56)); + instance.getMachine().call(1777, callArgs_9); + break label_2; + } + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = ((arg0 + 16) + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + local3 = 0; + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + local5 = memory.readLong((int) local4 < 0 ? local4 : local4 + 24); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 96, (long) local5); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-17, (int) local5) != 0) { + break label_9; + } + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 10) & 0xFF) != 0) { + break label_9; + } + local3 = ((local2 + 32) + 16); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + arg1 = ((local2 + 32) + 8); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) (local2 + 96)); + callArgs_10[0] = ((long) (local2 + 56)); + instance.getMachine().call(38, callArgs_10); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 32)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 56) : (local2 + 56))); + long[] callArgs_11 = new long[4]; + callArgs_11[3] = ((long) local2); + callArgs_11[2] = ((long) 11098); + callArgs_11[1] = ((long) (local2 + 8)); + callArgs_11[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_11); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), -1) != 0) { + break label_10; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 56)); + instance.getMachine().call(1777, callArgs_12); + } + local3 = 1; + break label_2; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local5); + } + instance.global(0).setValue(((long) (local2 + 112))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1195(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1195(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1196(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + int local8 = 0; + int local9 = 0; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(135, ((int) callResult_0[0])) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 16); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local4 = ((int) callResult_1[0]); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 15, (byte) (0)); + memory.writeLong((int) (local4 + 7) < 0 ? (local4 + 7) : (local4 + 7) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 14368)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 14361)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 12); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local5 = ((int) callResult_2[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local5); + local6 = (local5 + 12); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) local6); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 15); + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(1647, callArgs_3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local6); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 31038); + callArgs_4[1] = ((long) (local3 + 32)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1163, callArgs_4); + local6 = ((int) callResult_4[0]); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 11), -1) != 0) { + break label_4; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + instance.getMachine().call(1777, callArgs_5); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_6); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_7); + break label_2; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local5 = ((arg0 + 16) + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + memory.writeLong((int) ((local3 + 32) + 16) < 0 ? ((local3 + 32) + 16) : ((local3 + 32) + 16) + 0, (long) memory.readLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + memory.writeLong((int) ((local3 + 32) + 8) < 0 ? ((local3 + 32) + 8) : ((local3 + 32) + 8) + 0, (long) memory.readLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + label_5: { + local7 = memory.readLong((int) local5 < 0 ? local5 : local5 + 24); + local5 = (int) (local7 >>> 32L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 3) != 0) { + break label_5; + } + local4 = (local5 + -1); + local5 = (local5 + -2); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local5) != 0 ? local4 : local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, 1) != 0) { + break label_5; + } + local4 = (int) local7; + local8 = ((local5 + local4) + 1); + local5 = (local4 + 1); + label_6: while (true) { + label_7: { + label_8: { + local4 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(92, local4) != 0) { + break label_8; + } + local9 = (local5 + 1); + label_9: { + label_10: { + label_11: { + label_12: { + label_13: { + label_14: { + label_15: { + label_16: { + label_17: { + local4 = (int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 1); + switch((local4 + -92)) { + case 0: + { + break label_13; + } + case 1: + { + break label_9; + } + case 2: + { + break label_9; + } + case 3: + { + break label_9; + } + case 4: + { + break label_9; + } + case 5: + { + break label_9; + } + case 6: + { + break label_9; + } + case 7: + { + break label_9; + } + case 8: + { + break label_9; + } + case 9: + { + break label_9; + } + case 10: + { + break label_9; + } + case 11: + { + break label_9; + } + case 12: + { + break label_9; + } + case 13: + { + break label_9; + } + case 14: + { + break label_9; + } + case 15: + { + break label_9; + } + case 16: + { + break label_9; + } + case 17: + { + break label_9; + } + case 18: + { + break label_16; + } + case 19: + { + break label_9; + } + case 20: + { + break label_9; + } + case 21: + { + break label_9; + } + case 22: + { + break label_15; + } + case 23: + { + break label_9; + } + case 24: + { + break label_14; + } + case 25: + { + break label_10; + } + default: + { + break label_17; + } + } + } + switch((local4 + -34)) { + case 0: + { + break label_11; + } + case 1: + { + break label_9; + } + case 2: + { + break label_9; + } + case 3: + { + break label_9; + } + case 4: + { + break label_9; + } + case 5: + { + break label_12; + } + default: + { + break label_9; + } + } + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) 10); + callArgs_8[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_8); + break label_7; + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) 13); + callArgs_9[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_9); + break label_7; + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) 9); + callArgs_10[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_10); + break label_7; + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 92); + callArgs_11[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_11); + break label_7; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) 39); + callArgs_12[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_12); + break label_7; + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) 34); + callArgs_13[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_13); + break label_7; + } + local4 = (local5 + 3); + local6 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 3) & 0xFF); + local5 = 0; + label_18: while (true) { + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) (local3 + 60)); + callArgs_14[0] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6)); + long[] callResult_14 = instance.getMachine().call(546, callArgs_14); + local6 = ((int) callResult_14[0]); + local5 = (local6 != 0 ? local5 : (memory.readInt((int) local3 < 0 ? local3 : local3 + 60) | (local5 << 4))); + local6 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 1) & 0xFF); + local9 = (local4 + 1); + local4 = local9; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(125, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local5, 127) != 0) { + break label_19; + } + label_20: { + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 2047) != 0) { + break label_21; + } + local4 = ((local5 >>> 6) | -64); + break label_20; + } + label_22: { + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 65535) != 0) { + break label_23; + } + local4 = ((local5 >>> 12) | -32); + break label_22; + } + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) ((local5 >>> 18) | -16)); + callArgs_15[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_15); + local4 = (((local5 >>> 12) & 63) | -128); + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) local4); + callArgs_16[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_16); + local4 = (((local5 >>> 6) & 63) | -128); + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) local4); + callArgs_17[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_17); + local5 = ((local5 & 63) | -128); + } + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local5)); + callArgs_18[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_18); + break label_7; + } + label_24: { + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) (local3 + 60)); + callArgs_19[0] = ((long) local4); + long[] callResult_19 = instance.getMachine().call(546, callArgs_19); + if (((int) callResult_19[0]) != 0) { + break label_24; + } + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) (local3 + 56)); + callArgs_20[0] = ((long) (int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 2)); + long[] callResult_20 = instance.getMachine().call(546, callArgs_20); + if (((int) callResult_20[0]) != 0) { + break label_24; + } + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(((memory.readInt((int) local3 < 0 ? local3 : local3 + 60) << 4) | memory.readInt((int) local3 < 0 ? local3 : local3 + 56)))); + callArgs_21[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_21); + } + local9 = (local5 + 2); + break label_7; + } + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4)); + callArgs_22[0] = ((long) arg1); + instance.getMachine().call(1660, callArgs_22); + local9 = local5; + } + local5 = (local9 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + label_25: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_25; + } + local5 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11) & 0xFF); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local5), 0); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) (local4 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : local5)); + callArgs_23[0] = ((long) (local4 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : arg1)); + long[] callResult_23 = instance.getMachine().call(571, callArgs_23); + if (((int) callResult_23[0]) != 0) { + break label_25; + } + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) memory.readInt((int) ((local3 + 32) + 16) < 0 ? ((local3 + 32) + 16) : ((local3 + 32) + 16) + 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) ((local3 + 32) + 8) < 0 ? ((local3 + 32) + 8) : ((local3 + 32) + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 32)); + long[] callArgs_24 = new long[4]; + callArgs_24[3] = ((long) 0); + callArgs_24[2] = ((long) 14472); + callArgs_24[1] = ((long) (local3 + 8)); + callArgs_24[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_24); + } + local6 = 0; + } + instance.global(0).setValue(((long) (local3 + 64))); + return local6; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1196(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1196(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1197(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local2 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + local3 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(133, local3) != 0) { + break label_3; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local5 = ((arg0 + 16) + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + memory.writeLong((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0, (long) memory.readLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + local6 = ((local2 + 72) + 8); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + label_4: { + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) 1); + callArgs_1[2] = ((long) (local2 + 64)); + callArgs_1[1] = ((long) (local4 + local5)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(548, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_1[0])) != 0) { + break label_4; + } + memory.writeI32((int) ((local2 + 40) + 16) < 0 ? ((local2 + 40) + 16) : ((local2 + 40) + 16) + 0, (int) memory.readInt((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0)); + memory.writeLong((int) ((local2 + 40) + 8) < 0 ? ((local2 + 40) + 8) : ((local2 + 40) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) local4); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local2 + 32)); + callArgs_2[2] = ((long) 30777); + callArgs_2[1] = ((long) (local2 + 40)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_2); + } + local7 = memory.readLong((int) local2 < 0 ? local2 : local2 + 64); + label_5: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 14) & 0xFF) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local7, 4294967296L) != 0) { + break label_5; + } + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) 0); + callArgs_3[2] = ((long) 14764); + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_3); + local7 = memory.readLong((int) local2 < 0 ? local2 : local2 + 64); + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local7); + break label_2; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + } + instance.global(0).setValue(((long) (local2 + 96))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(133, local3); + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1197(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1197(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1198(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + local3 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(131, local3) != 0) { + break label_3; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local5 = ((arg0 + 16) + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + memory.writeLong((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0, (long) memory.readLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + local6 = ((local2 + 72) + 8); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + label_4: { + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (local4 + local5)); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(548, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_1[0])) != 0) { + break label_4; + } + memory.writeI32((int) ((local2 + 48) + 16) < 0 ? ((local2 + 48) + 16) : ((local2 + 48) + 16) + 0, (int) memory.readInt((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0)); + memory.writeLong((int) ((local2 + 48) + 8) < 0 ? ((local2 + 48) + 8) : ((local2 + 48) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) local5); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) local4); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local2 + 32)); + callArgs_2[2] = ((long) 30752); + callArgs_2[1] = ((long) (local2 + 48)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_2); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0))) != 0) { + break label_2; + } + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) 0); + callArgs_3[2] = ((long) 11947); + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_3); + break label_2; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) -1L); + } + instance.global(0).setValue(((long) (local2 + 96))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(131, local3); + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1198(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1198(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1199(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(31, ((int) callResult_1[0])) != 0) { + break label_3; + } + label_4: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 15) & 0xFF) != 0) { + break label_4; + } + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) 0); + callArgs_2[2] = ((long) 18254); + callArgs_2[1] = ((long) (local3 + 8)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_2); + arg1 = 1; + break label_1; + } + arg1 = 1; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 30); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1160, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_1; + } + arg1 = 1; + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 31); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1160, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_1; + } + arg1 = 1; + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1166, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_1; + } + arg1 = 1; + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 44); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1160, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_6[0])) != 0) { + break label_2; + } + break label_1; + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) arg1); + callArgs_7[1] = ((long) 0); + callArgs_7[0] = ((long) (local3 + 56)); + long[] callResult_7 = instance.getMachine().call(155, callArgs_7); + local4 = ((int) callResult_7[0]); + label_5: { + label_6: { + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) 0); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1154, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(59, ((int) callResult_8[0])) != 0) { + break label_6; + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) 0); + callArgs_9[0] = ((long) arg0); + long[] callResult_9 = instance.getMachine().call(1154, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_9[0])) != 0) { + break label_5; + } + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) arg2); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1166, callArgs_10); + arg2 = ((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 15) & 0xFF); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local4); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + if (arg2 != 0) { + break label_2; + } + memory.writeI32((int) ((local3 + 32) + 16) < 0 ? ((local3 + 32) + 16) : ((local3 + 32) + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) ((local3 + 32) + 8) < 0 ? ((local3 + 32) + 8) : ((local3 + 32) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_12 = new long[4]; + callArgs_12[3] = ((long) 0); + callArgs_12[2] = ((long) 18254); + callArgs_12[1] = ((long) (local3 + 32)); + callArgs_12[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_12); + arg1 = 1; + break label_1; + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) local4); + callArgs_13[0] = ((long) arg2); + long[] callResult_13 = instance.getMachine().call(160, callArgs_13); + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local4); + long[] callResult_14 = instance.getMachine().call(162, callArgs_14); + } + arg1 = 0; + } + instance.global(0).setValue(((long) (local3 + 96))); + return arg1; + } + + public static long[] call_1199(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1199(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1200(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(137, ((int) callResult_0[0])) != 0) { + break label_2; + } + label_3: { + local3 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 8)); + instance.getMachine().call(557, callArgs_1); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 8) + 24) < 0 ? ((local2 + 8) + 24) : ((local2 + 8) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 8) + 32) < 0 ? ((local2 + 8) + 32) : ((local2 + 8) + 32) + 0)); + label_4: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_4; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + local5 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_1; + } + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-2, memory.readInt((int) local5 < 0 ? local5 : local5 + 24)) != 0) { + break label_6; + } + local3 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + local3 = (local3 + 36); + local5 = 1; + break label_5; + } + label_7: { + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_7; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_2[0] = ((long) (local2 + 8)); + instance.getMachine().call(557, callArgs_2); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 8) + 24) < 0 ? ((local2 + 8) + 24) : ((local2 + 8) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 8) + 32) < 0 ? ((local2 + 8) + 32) : ((local2 + 8) + 32) + 0)); + label_8: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_8; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_7; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + local5 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) local5 < 0 ? local5 : local5 + 24)) != 0) { + break label_2; + } + local3 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + local3 = (local3 + 36); + local5 = 0; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (0)); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 18, (byte) (local5)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + } + instance.global(0).setValue(((long) (local2 + 48))); + return 0; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1200(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1200(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1201(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = 1; + label_1: { + label_2: { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 18) & 0xFF)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1202, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_2; + } + local2 = 0; + label_3: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(59, ((int) callResult_1[0])) != 0) { + break label_3; + } + local2 = 1; + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 18) & 0xFF)); + callArgs_2[1] = ((long) (arg1 + 8)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1202, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_2; + } + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 16, (byte) (local2)); + local2 = 0; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1154, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(45, ((int) callResult_3[0])) != 0) { + break label_2; + } + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = ((arg0 + (local3 * 40)) + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_1; + } + local2 = 0; + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (0)); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 17, (byte) (1)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + } + return local2; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1201(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1201(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1202(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(59, ((int) callResult_0[0])) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 32); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg1 = ((int) callResult_1[0]); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 16, (byte) (0)); + memory.writeLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 11764)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 11756)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 12); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local4); + arg2 = (local4 + 12); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) arg2); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 16); + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) local4); + instance.getMachine().call(1647, callArgs_3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) arg2); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 28097); + callArgs_4[1] = ((long) (local3 + 32)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1163, callArgs_4); + arg0 = ((int) callResult_4[0]); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_4; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_5); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_6); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_7); + break label_2; + } + local5 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = ((arg0 + 16) + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + memory.writeI32((int) ((local3 + 32) + 24) < 0 ? ((local3 + 32) + 24) : ((local3 + 32) + 24) + 0, (int) memory.readInt((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0)); + memory.writeLong((int) ((local3 + 32) + 16) < 0 ? ((local3 + 32) + 16) : ((local3 + 32) + 16) + 0, (long) memory.readLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + local5 = ((local3 + 32) + 8); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + label_5: { + label_6: { + local6 = memory.readLong((int) local4 < 0 ? local4 : local4 + 28); + local4 = (int) local6; + local7 = (int) (local6 >>> 32L); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) arg1); + callArgs_8[1] = ((long) (local4 + local7)); + callArgs_8[0] = ((long) local4); + long[] callResult_8 = instance.getMachine().call(547, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_8[0])) != 0) { + break label_6; + } + if (arg2 != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0), 4294967296L) != 0) { + break label_5; + } + } + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) memory.readInt((int) ((local3 + 32) + 16) < 0 ? ((local3 + 32) + 16) : ((local3 + 32) + 16) + 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 32)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local7); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local4); + long[] callArgs_9 = new long[4]; + callArgs_9[3] = ((long) local3); + callArgs_9[2] = ((long) 30733); + callArgs_9[1] = ((long) (local3 + 8)); + callArgs_9[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_9); + } + arg0 = 0; + } + instance.global(0).setValue(((long) (local3 + 64))); + return arg0; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1202(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1202(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1203(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + local3 = 0; + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_2; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(38, ((int) callResult_1[0])) != 0) { + break label_2; + } + label_3: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 18) & 0xFF) != 0) { + break label_3; + } + label_4: { + arg1 = (arg0 + 16); + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (arg1 + (local3 * 40)) < 0 ? (arg1 + (local3 * 40)) : (arg1 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_2[0] = ((long) (local2 + 104)); + instance.getMachine().call(557, callArgs_2); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local4 = (arg1 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) * 40)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) ((local2 + 104) + 8) < 0 ? ((local2 + 104) + 8) : ((local2 + 104) + 8) + 0)); + memory.writeLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (long) memory.readLong((int) ((local2 + 104) + 16) < 0 ? ((local2 + 104) + 16) : ((local2 + 104) + 16) + 0)); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) memory.readLong((int) ((local2 + 104) + 24) < 0 ? ((local2 + 104) + 24) : ((local2 + 104) + 24) + 0)); + memory.writeI32((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (int) memory.readInt((int) ((local2 + 104) + 32) < 0 ? ((local2 + 104) + 32) : ((local2 + 104) + 32) + 0)); + label_5: { + if (((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF) != 0) { + break label_5; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (1)); + } + if (((int) memory.read((int) (arg1 + (local3 * 40)) < 0 ? (arg1 + (local3 * 40)) : (arg1 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + local3 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + } + local3 = (arg1 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) 0); + callArgs_3[2] = ((long) 18168); + callArgs_3[1] = ((long) (local2 + 8)); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_3); + local3 = 1; + break label_2; + } + local3 = 1; + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 30); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1160, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_2; + } + local3 = 1; + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 38); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1160, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_2; + } + label_6: { + local5 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local5 + (local4 * 40)) < 0 ? (local5 + (local4 * 40)) : (local5 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_6; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_6[0] = ((long) (local2 + 104)); + instance.getMachine().call(557, callArgs_6); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local6 = (local5 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) ((local2 + 104) + 8) < 0 ? ((local2 + 104) + 8) : ((local2 + 104) + 8) + 0)); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) memory.readLong((int) ((local2 + 104) + 16) < 0 ? ((local2 + 104) + 16) : ((local2 + 104) + 16) + 0)); + memory.writeLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0, (long) memory.readLong((int) ((local2 + 104) + 24) < 0 ? ((local2 + 104) + 24) : ((local2 + 104) + 24) + 0)); + memory.writeI32((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0, (int) memory.readInt((int) ((local2 + 104) + 32) < 0 ? ((local2 + 104) + 32) : ((local2 + 104) + 32) + 0)); + label_7: { + if (((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF) != 0) { + break label_7; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local5 + (local4 * 40)) < 0 ? (local5 + (local4 * 40)) : (local5 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_6; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + local6 = (local5 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF)) != 0) { + break label_1; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((memory.readInt((int) local6 < 0 ? local6 : local6 + 20) + -57), 3) != 0) { + break label_8; + } + label_9: { + if (((int) memory.read((int) (local5 + (local4 * 40)) < 0 ? (local5 + (local4 * 40)) : (local5 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_9; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_7[0] = ((long) (local2 + 104)); + instance.getMachine().call(557, callArgs_7); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + arg1 = (local5 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (long) memory.readLong((int) ((local2 + 104) + 8) < 0 ? ((local2 + 104) + 8) : ((local2 + 104) + 8) + 0)); + memory.writeLong((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (long) memory.readLong((int) ((local2 + 104) + 16) < 0 ? ((local2 + 104) + 16) : ((local2 + 104) + 16) + 0)); + memory.writeLong((int) (arg1 + 24) < 0 ? (arg1 + 24) : (arg1 + 24) + 0, (long) memory.readLong((int) ((local2 + 104) + 24) < 0 ? ((local2 + 104) + 24) : ((local2 + 104) + 24) + 0)); + memory.writeI32((int) (arg1 + 32) < 0 ? (arg1 + 32) : (arg1 + 32) + 0, (int) memory.readInt((int) ((local2 + 104) + 32) < 0 ? ((local2 + 104) + 32) : ((local2 + 104) + 32) + 0)); + label_10: { + if (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 36) & 0xFF) != 0) { + break label_10; + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local5 + (local4 * 40)) < 0 ? (local5 + (local4 * 40)) : (local5 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_9; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + arg1 = (local5 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeLong((int) ((local2 + 56) + 8) < 0 ? ((local2 + 56) + 8) : ((local2 + 56) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) ((local2 + 56) + 16) < 0 ? ((local2 + 56) + 16) : ((local2 + 56) + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 0); + callArgs_8[2] = ((long) 15160); + callArgs_8[1] = ((long) (local2 + 56)); + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_8); + break label_2; + } + local7 = memory.readLong((int) local6 < 0 ? local6 : local6 + 28); + local3 = (int) local7; + long[] callArgs_9 = new long[4]; + callArgs_9[3] = ((long) 0); + callArgs_9[2] = ((long) arg1); + callArgs_9[1] = ((long) (local3 + (int) (local7 >>> 32L))); + callArgs_9[0] = ((long) local3); + long[] callResult_9 = instance.getMachine().call(551, callArgs_9); + local4 = ((int) callResult_9[0]); + local3 = 1; + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0))) != 0) { + break label_11; + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) arg0); + callArgs_10[0] = ((long) (local2 + 80)); + instance.getMachine().call(1153, callArgs_10); + memory.writeI32((int) ((local2 + 32) + 16) < 0 ? ((local2 + 32) + 16) : ((local2 + 32) + 16) + 0, (int) memory.readInt((int) ((local2 + 80) + 16) < 0 ? ((local2 + 80) + 16) : ((local2 + 80) + 16) + 0)); + memory.writeLong((int) ((local2 + 32) + 8) < 0 ? ((local2 + 32) + 8) : ((local2 + 32) + 8) + 0, (long) memory.readLong((int) ((local2 + 80) + 8) < 0 ? ((local2 + 80) + 8) : ((local2 + 80) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 80)); + long[] callArgs_11 = new long[4]; + callArgs_11[3] = ((long) 0); + callArgs_11[2] = ((long) 15160); + callArgs_11[1] = ((long) (local2 + 32)); + callArgs_11[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_11); + break label_2; + } + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + arg1 = (local5 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (arg1 + 36) < 0 ? (arg1 + 36) : (arg1 + 36) + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) 44); + callArgs_12[0] = ((long) arg0); + long[] callResult_12 = instance.getMachine().call(1160, callArgs_12); + local3 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4)); + } + instance.global(0).setValue(((long) (local2 + 144))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1203(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1203(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1204(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + local2 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 404); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 392); + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) ((int) callResult_0[0])); + long[] callResult_1 = instance.getMachine().call(1892, callArgs_1); + local3 = ((int) callResult_1[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 228, (long) 0L); + memory.writeI32((int) (local3 + 224) < 0 ? (local3 + 224) : (local3 + 224) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 236) < 0 ? (local3 + 236) : (local3 + 236) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 248, (long) 0L); + memory.writeI32((int) (local3 + 244) < 0 ? (local3 + 244) : (local3 + 244) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 256) < 0 ? (local3 + 256) : (local3 + 256) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 268, (long) 0L); + memory.writeI32((int) (local3 + 264) < 0 ? (local3 + 264) : (local3 + 264) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 276) < 0 ? (local3 + 276) : (local3 + 276) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 288, (long) 0L); + memory.writeI32((int) (local3 + 284) < 0 ? (local3 + 284) : (local3 + 284) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 296) < 0 ? (local3 + 296) : (local3 + 296) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 308, (long) 0L); + memory.writeI32((int) (local3 + 304) < 0 ? (local3 + 304) : (local3 + 304) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 316) < 0 ? (local3 + 316) : (local3 + 316) + 0, (long) 0L); + memory.writeI32((int) (local3 + 324) < 0 ? (local3 + 324) : (local3 + 324) + 0, (int) 1065353216); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 328, (long) 0L); + memory.writeLong((int) (local3 + 336) < 0 ? (local3 + 336) : (local3 + 336) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 348, (long) 0L); + memory.writeI32((int) (local3 + 344) < 0 ? (local3 + 344) : (local3 + 344) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 356) < 0 ? (local3 + 356) : (local3 + 356) + 0, (long) 0L); + memory.writeI32((int) (local3 + 364) < 0 ? (local3 + 364) : (local3 + 364) + 0, (int) 1065353216); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 368, (long) 0L); + memory.writeLong((int) (local3 + 376) < 0 ? (local3 + 376) : (local3 + 376) + 0, (long) 0L); + local4 = (local3 + 396); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeI32((int) (local3 + 384) < 0 ? (local3 + 384) : (local3 + 384) + 0, (int) 1065353216); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 392, (int) local4); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1154, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_2[0])) != 0) { + break label_5; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1154, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(32, ((int) callResult_3[0])) != 0) { + break label_5; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) 0); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (local2 + 24)); + callArgs_4[1] = ((long) 0); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1205, callArgs_4); + local5 = ((int) callResult_4[0]); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 24); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5) != 0) { + break label_6; + } + label_7: { + if (memory.readInt((int) local4 < 0 ? local4 : local4 + 4) != 0) { + break label_7; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local4 + 8)); + callArgs_5[0] = ((long) local3); + long[] callResult_5 = instance.getMachine().call(1206, callArgs_5); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local4); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + break label_4; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) (local4 + 8)); + callArgs_7[0] = ((long) local3); + long[] callResult_7 = instance.getMachine().call(1206, callArgs_7); + int ciTableIdx_8 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local4); + ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + break label_4; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_8; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + local4 = 1; + arg0 = local3; + break label_3; + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) 0); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1154, callArgs_10); + local4 = ((int) callResult_10[0]); + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 1); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1154, callArgs_11); + local5 = ((int) callResult_11[0]); + label_9: { + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, local4) != 0) { + break label_11; + } + label_12: { + switch((local5 + -13)) { + case 0: + { + break label_10; + } + case 1: + { + break label_11; + } + case 2: + { + break label_11; + } + case 3: + { + break label_11; + } + case 4: + { + break label_11; + } + case 5: + { + break label_10; + } + case 6: + { + break label_11; + } + case 7: + { + break label_10; + } + case 8: + { + break label_10; + } + case 9: + { + break label_11; + } + case 10: + { + break label_11; + } + case 11: + { + break label_11; + } + case 12: + { + break label_10; + } + case 13: + { + break label_10; + } + case 14: + { + break label_11; + } + case 15: + { + break label_11; + } + case 16: + { + break label_11; + } + case 17: + { + break label_11; + } + case 18: + { + break label_10; + } + case 19: + { + break label_11; + } + case 20: + { + break label_11; + } + case 21: + { + break label_11; + } + case 22: + { + break label_11; + } + case 23: + { + break label_11; + } + case 24: + { + break label_11; + } + case 25: + { + break label_11; + } + case 26: + { + break label_11; + } + case 27: + { + break label_11; + } + case 28: + { + break label_11; + } + case 29: + { + break label_11; + } + case 30: + { + break label_11; + } + case 31: + { + break label_11; + } + case 32: + { + break label_11; + } + case 33: + { + break label_10; + } + case 34: + { + break label_11; + } + case 35: + { + break label_10; + } + case 36: + { + break label_11; + } + case 37: + { + break label_10; + } + default: + { + break label_12; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(138, local5) != 0) { + break label_10; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 11) & 0xFF)) != 0) { + break label_9; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) 0); + callArgs_12[0] = ((long) arg0); + long[] callResult_12 = instance.getMachine().call(1154, callArgs_12); + local4 = ((int) callResult_12[0]); + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) 1); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(1154, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(132, local4) != 0) { + break label_9; + } + local4 = (arg0 + (((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF) * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (local4 + 52) < 0 ? (local4 + 52) : (local4 + 52) + 0) & 0xFF)) != 0) { + break label_1; + } + local6 = memory.readLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(25769803776L, (local6 & -4294967296L)) != 0) { + break label_9; + } + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) 6); + callArgs_14[1] = ((long) 13015); + callArgs_14[0] = ((long) (int) local6); + long[] callResult_14 = instance.getMachine().call(1889, callArgs_14); + if (((int) callResult_14[0]) != 0) { + break label_9; + } + } + local4 = 1; + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) local3); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1207, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_15[0])) != 0) { + break label_4; + } + arg0 = local3; + break label_3; + } + label_13: { + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) 0); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1154, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(19, ((int) callResult_16[0])) != 0) { + break label_13; + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) 0); + label_14: { + local5 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local5 + (local4 * 40)) < 0 ? (local5 + (local4 * 40)) : (local5 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_14; + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_17[0] = ((long) (local2 + 24)); + instance.getMachine().call(557, callArgs_17); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local8 = (local5 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 24)); + memory.writeLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (long) memory.readLong((int) ((local2 + 24) + 8) < 0 ? ((local2 + 24) + 8) : ((local2 + 24) + 8) + 0)); + memory.writeLong((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0, (long) memory.readLong((int) ((local2 + 24) + 16) < 0 ? ((local2 + 24) + 16) : ((local2 + 24) + 16) + 0)); + memory.writeLong((int) (local8 + 24) < 0 ? (local8 + 24) : (local8 + 24) + 0, (long) memory.readLong((int) ((local2 + 24) + 24) < 0 ? ((local2 + 24) + 24) : ((local2 + 24) + 24) + 0)); + memory.writeI32((int) (local8 + 32) < 0 ? (local8 + 32) : (local8 + 32) + 0, (int) memory.readInt((int) ((local2 + 24) + 32) < 0 ? ((local2 + 24) + 32) : ((local2 + 24) + 32) + 0)); + label_15: { + if (((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF) != 0) { + break label_15; + } + memory.writeByte((int) local8 < 0 ? local8 : local8 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local5 + (local4 * 40)) < 0 ? (local5 + (local4 * 40)) : (local5 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_14; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + local4 = (local5 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + local8 = (local4 + 16); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + local9 = (local4 + 8); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) memory.readLong((int) local9 < 0 ? local9 : local9 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + label_16: { + local5 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, memory.readInt((int) local7 < 0 ? local7 : local7 + 8)) != 0) { + break label_16; + } + local8 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + memory.writeI32((int) ((local2 + 24) + 16) < 0 ? ((local2 + 24) + 16) : ((local2 + 24) + 16) + 0, (int) local8); + local10 = memory.readLong((int) local9 < 0 ? local9 : local9 + 0); + memory.writeLong((int) ((local2 + 24) + 8) < 0 ? ((local2 + 24) + 8) : ((local2 + 24) + 8) + 0, (long) local10); + local6 = memory.readLong((int) local4 < 0 ? local4 : local4 + 0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 4, (long) local6); + memory.writeLong((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0, (long) local10); + memory.writeI32((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0, (int) local8); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) local6); + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) 16); + long[] callResult_18 = instance.getMachine().call(1776, callArgs_18); + local4 = ((int) callResult_18[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local4); + memory.writeLong((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (long) -9223371968135299060L); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 17045)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 17037)); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 12, (byte) (0)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 4, (int) (local5 + 36)); + break label_4; + } + long[] callArgs_19 = new long[4]; + callArgs_19[3] = ((long) 17037); + callArgs_19[2] = ((long) local2); + callArgs_19[1] = ((long) (local2 + 20)); + callArgs_19[0] = ((long) local7); + instance.getMachine().call(1208, callArgs_19); + break label_4; + } + label_17: { + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) 0); + callArgs_20[0] = ((long) arg0); + long[] callResult_20 = instance.getMachine().call(1154, callArgs_20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_20[0])) != 0) { + break label_17; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local5 = ((arg0 + (local4 * 40)) + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) 16); + long[] callResult_21 = instance.getMachine().call(1776, callArgs_21); + local5 = ((int) callResult_21[0]); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 14, (byte) (0)); + memory.writeByte((int) (local2 + 44) < 0 ? (local2 + 44) : (local2 + 44) + 0, (byte) (0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 17885)); + memory.writeLong((int) (local5 + 6) < 0 ? (local5 + 6) : (local5 + 6) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 17891)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) -2147483632); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local5); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 47, (byte) (8)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 36, (long) 7308345369542074465L); + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) 24); + long[] callResult_22 = instance.getMachine().call(1776, callArgs_22); + local4 = ((int) callResult_22[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) (local4 + 24)); + long[] callArgs_23 = new long[3]; + callArgs_23[2] = ((long) 14); + callArgs_23[1] = ((long) local5); + callArgs_23[0] = ((long) local4); + instance.getMachine().call(1647, callArgs_23); + local5 = (local4 + 12); + label_18: { + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 47), 0) != 0) { + break label_19; + } + local7 = ((local2 + 24) + 12); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0)); + break label_18; + } + long[] callArgs_24 = new long[3]; + callArgs_24[2] = ((long) memory.readInt((int) ((local2 + 24) + 16) < 0 ? ((local2 + 24) + 16) : ((local2 + 24) + 16) + 0)); + callArgs_24[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 36)); + callArgs_24[0] = ((long) local5); + instance.getMachine().call(1647, callArgs_24); + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (local4 + 24)); + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) 0); + callArgs_25[1] = ((long) local2); + callArgs_25[0] = ((long) arg0); + long[] callResult_25 = instance.getMachine().call(1163, callArgs_25); + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 23), -1) != 0) { + break label_20; + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 12)); + instance.getMachine().call(1777, callArgs_26); + } + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_21; + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_27); + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_28); + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 47), -1) != 0) { + break label_22; + } + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 36)); + instance.getMachine().call(1777, callArgs_29); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 35), -1) != 0) { + break label_4; + } + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 24)); + instance.getMachine().call(1777, callArgs_30); + } + local4 = 1; + label_23: { + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) 19); + callArgs_31[0] = ((long) arg0); + long[] callResult_31 = instance.getMachine().call(1160, callArgs_31); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_31[0])) != 0) { + break label_23; + } + arg0 = local3; + break label_3; + } + label_24: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, arg0) != 0) { + break label_24; + } + label_25: { + label_26: while (true) { + local4 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_25; + } + arg0 = (arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, arg0) != 0) { + break label_24; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_26; + } + } + arg0 = local3; + break label_3; + } + arg0 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_2; + } + } + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) arg0); + long[] callResult_32 = instance.getMachine().call(32, callArgs_32); + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) ((int) callResult_32[0])); + instance.getMachine().call(1777, callArgs_33); + } + instance.global(0).setValue(((long) (local2 + 64))); + return local4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1204(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1204(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1205(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + long local12 = 0L; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + local3 = (((int) instance.global(0).getValue()) - 288); + instance.global(0).setValue(((long) local3)); + local4 = 0; + memory.writeI32((int) local3 < 0 ? local3 : local3 + 160, (int) 0); + local5 = 1; + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 160)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1209, callArgs_0); + local6 = ((int) callResult_0[0]); + local7 = memory.readInt((int) local3 < 0 ? local3 : local3 + 160); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6) != 0) { + break label_1; + } + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + switch(memory.readInt((int) local7 < 0 ? local7 : local7 + 4)) { + case 0: + { + break label_6; + } + case 1: + { + break label_5; + } + case 2: + { + break label_4; + } + default: + { + break label_2; + } + } + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 412); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 400); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) ((int) callResult_1[0])); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + local5 = ((int) callResult_2[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 49708); + local4 = (local5 + 8); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 224); + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = instance.getMachine().call(1892, callArgs_3); + local6 = ((int) callResult_3[0]); + memory.writeLong((int) (local5 + 236) < 0 ? (local5 + 236) : (local5 + 236) + 0, (long) 0L); + memory.writeI32((int) (local5 + 232) < 0 ? (local5 + 232) : (local5 + 232) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 244) < 0 ? (local5 + 244) : (local5 + 244) + 0, (long) 0L); + memory.writeLong((int) (local5 + 256) < 0 ? (local5 + 256) : (local5 + 256) + 0, (long) 0L); + memory.writeI32((int) (local5 + 252) < 0 ? (local5 + 252) : (local5 + 252) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 264) < 0 ? (local5 + 264) : (local5 + 264) + 0, (long) 0L); + memory.writeLong((int) (local5 + 276) < 0 ? (local5 + 276) : (local5 + 276) + 0, (long) 0L); + memory.writeI32((int) (local5 + 272) < 0 ? (local5 + 272) : (local5 + 272) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 284) < 0 ? (local5 + 284) : (local5 + 284) + 0, (long) 0L); + memory.writeLong((int) (local5 + 296) < 0 ? (local5 + 296) : (local5 + 296) + 0, (long) 0L); + memory.writeI32((int) (local5 + 292) < 0 ? (local5 + 292) : (local5 + 292) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 304) < 0 ? (local5 + 304) : (local5 + 304) + 0, (long) 0L); + memory.writeLong((int) (local5 + 316) < 0 ? (local5 + 316) : (local5 + 316) + 0, (long) 0L); + memory.writeI32((int) (local5 + 312) < 0 ? (local5 + 312) : (local5 + 312) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 324) < 0 ? (local5 + 324) : (local5 + 324) + 0, (long) 0L); + memory.writeI32((int) (local5 + 332) < 0 ? (local5 + 332) : (local5 + 332) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 336) < 0 ? (local5 + 336) : (local5 + 336) + 0, (long) 0L); + memory.writeLong((int) (local5 + 344) < 0 ? (local5 + 344) : (local5 + 344) + 0, (long) 0L); + memory.writeLong((int) (local5 + 356) < 0 ? (local5 + 356) : (local5 + 356) + 0, (long) 0L); + memory.writeI32((int) (local5 + 352) < 0 ? (local5 + 352) : (local5 + 352) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 364) < 0 ? (local5 + 364) : (local5 + 364) + 0, (long) 0L); + memory.writeI32((int) (local5 + 372) < 0 ? (local5 + 372) : (local5 + 372) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 376) < 0 ? (local5 + 376) : (local5 + 376) + 0, (long) 0L); + memory.writeLong((int) (local5 + 384) < 0 ? (local5 + 384) : (local5 + 384) + 0, (long) 0L); + local8 = (local5 + 404); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + memory.writeI32((int) (local5 + 392) < 0 ? (local5 + 392) : (local5 + 392) + 0, (int) 1065353216); + memory.writeI32((int) (local5 + 400) < 0 ? (local5 + 400) : (local5 + 400) + 0, (int) local8); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local7 + 8)); + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1206, callArgs_4); + local6 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 4)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local6); + ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + break label_2; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) 416); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + local8 = ((int) callResult_6[0]); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 4, (int) 1); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) 58248); + local6 = (local8 + 392); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + local9 = (local8 + 384); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) 0L); + local4 = (local8 + 8); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 224); + callArgs_7[1] = ((long) 0); + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(1892, callArgs_7); + local5 = ((int) callResult_7[0]); + memory.writeLong((int) (local8 + 236) < 0 ? (local8 + 236) : (local8 + 236) + 0, (long) 0L); + memory.writeI32((int) (local8 + 232) < 0 ? (local8 + 232) : (local8 + 232) + 0, (int) 1065353216); + memory.writeLong((int) (local8 + 244) < 0 ? (local8 + 244) : (local8 + 244) + 0, (long) 0L); + memory.writeLong((int) (local8 + 256) < 0 ? (local8 + 256) : (local8 + 256) + 0, (long) 0L); + memory.writeI32((int) (local8 + 252) < 0 ? (local8 + 252) : (local8 + 252) + 0, (int) 1065353216); + memory.writeLong((int) (local8 + 264) < 0 ? (local8 + 264) : (local8 + 264) + 0, (long) 0L); + memory.writeLong((int) (local8 + 276) < 0 ? (local8 + 276) : (local8 + 276) + 0, (long) 0L); + memory.writeI32((int) (local8 + 272) < 0 ? (local8 + 272) : (local8 + 272) + 0, (int) 1065353216); + memory.writeLong((int) (local8 + 284) < 0 ? (local8 + 284) : (local8 + 284) + 0, (long) 0L); + memory.writeLong((int) (local8 + 296) < 0 ? (local8 + 296) : (local8 + 296) + 0, (long) 0L); + memory.writeI32((int) (local8 + 292) < 0 ? (local8 + 292) : (local8 + 292) + 0, (int) 1065353216); + memory.writeLong((int) (local8 + 304) < 0 ? (local8 + 304) : (local8 + 304) + 0, (long) 0L); + memory.writeLong((int) (local8 + 316) < 0 ? (local8 + 316) : (local8 + 316) + 0, (long) 0L); + memory.writeI32((int) (local8 + 312) < 0 ? (local8 + 312) : (local8 + 312) + 0, (int) 1065353216); + memory.writeLong((int) (local8 + 324) < 0 ? (local8 + 324) : (local8 + 324) + 0, (long) 0L); + memory.writeI32((int) (local8 + 332) < 0 ? (local8 + 332) : (local8 + 332) + 0, (int) 1065353216); + memory.writeLong((int) (local8 + 336) < 0 ? (local8 + 336) : (local8 + 336) + 0, (long) 0L); + memory.writeLong((int) (local8 + 344) < 0 ? (local8 + 344) : (local8 + 344) + 0, (long) 0L); + memory.writeLong((int) (local8 + 364) < 0 ? (local8 + 364) : (local8 + 364) + 0, (long) 0L); + memory.writeLong((int) (local8 + 356) < 0 ? (local8 + 356) : (local8 + 356) + 0, (long) 0L); + memory.writeI32((int) (local8 + 352) < 0 ? (local8 + 352) : (local8 + 352) + 0, (int) 1065353216); + memory.writeI32((int) (local8 + 372) < 0 ? (local8 + 372) : (local8 + 372) + 0, (int) 1065353216); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) 0L); + memory.writeLong((int) (local8 + 376) < 0 ? (local8 + 376) : (local8 + 376) + 0, (long) 0L); + local9 = (local8 + 404); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 1065353216); + memory.writeI32((int) (local8 + 400) < 0 ? (local8 + 400) : (local8 + 400) + 0, (int) local9); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 412, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 188, (long) 282574488338432L); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + memory.writeLong((int) ((local3 + 168) + 8) < 0 ? ((local3 + 168) + 8) : ((local3 + 168) + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + memory.writeI32((int) ((local3 + 168) + 15) < 0 ? ((local3 + 168) + 15) : ((local3 + 168) + 15) + 0, (int) memory.readInt((int) (local6 + 15) < 0 ? (local6 + 15) : (local6 + 15) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 168, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 280, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 272, (long) 0L); + local6 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + long[] callArgs_8 = new long[6]; + callArgs_8[5] = ((long) local5); + callArgs_8[4] = ((long) (local3 + 272)); + callArgs_8[3] = ((long) (local3 + 168)); + callArgs_8[2] = ((long) (memory.readInt((int) (local7 + 44) < 0 ? (local7 + 44) : (local7 + 44) + 0) - local6)); + callArgs_8[1] = ((long) local6); + callArgs_8[0] = ((long) 27450); + long[] callResult_8 = instance.getMachine().call(838, callArgs_8); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local8) != 0) { + break label_7; + } + local9 = (local7 + 28); + local6 = (local8 + 28); + local10 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 39) & 0xFF); + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local10); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local8 < 0 ? local8 : local8 + 39), 0) != 0) { + break label_8; + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local11, 0) != 0) { + break label_9; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local9 < 0 ? local9 : local9 + 0)); + memory.writeI32((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (int) memory.readInt((int) (local9 + 8) < 0 ? (local9 + 8) : (local9 + 8) + 0)); + break label_7; + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) memory.readInt((int) (local7 + 32) < 0 ? (local7 + 32) : (local7 + 32) + 0)); + callArgs_9[1] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 28)); + callArgs_9[0] = ((long) local6); + long[] callResult_9 = instance.getMachine().call(1659, callArgs_9); + break label_7; + } + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local11, 0); + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) (local11 != 0 ? memory.readInt((int) (local7 + 32) < 0 ? (local7 + 32) : (local7 + 32) + 0) : local10)); + callArgs_10[1] = ((long) (local11 != 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 28) : local9)); + callArgs_10[0] = ((long) local6); + long[] callResult_10 = instance.getMachine().call(1658, callArgs_10); + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 8)); + memory.writeI32((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (int) memory.readInt((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0)); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 272); + local10 = memory.readInt((int) local3 < 0 ? local3 : local3 + 276); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local10, local5) != 0) { + break label_3; + } + local6 = (local7 + 8); + local5 = (local5 + 24); + label_10: while (true) { + label_11: { + label_12: { + local7 = (local5 + -12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) local7 < 0 ? local7 : local7 + 0)) != 0) { + break label_12; + } + local7 = (int) (byte) memory.read((int) (local5 + 11) < 0 ? (local5 + 11) : (local5 + 11) + 0); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) memory.readInt((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0) != 0 ? local9 : local5)); + long[] callArgs_11 = new long[4]; + callArgs_11[3] = ((long) local3); + callArgs_11[2] = ((long) 11044); + callArgs_11[1] = ((long) (local3 + 8)); + callArgs_11[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_11); + break label_11; + } + local9 = (int) (byte) memory.read((int) (local5 + 11) < 0 ? (local5 + 11) : (local5 + 11) + 0); + local11 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local7 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + memory.writeI32((int) ((local3 + 40) + 16) < 0 ? ((local3 + 40) + 16) : ((local3 + 40) + 16) + 0, (int) memory.readInt((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) ((local3 + 40) + 8) < 0 ? ((local3 + 40) + 8) : ((local3 + 40) + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + local12 = memory.readLong((int) local6 < 0 ? local6 : local6 + 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local7); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) local12); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local9, 0) != 0 ? local11 : local5)); + long[] callArgs_12 = new long[4]; + callArgs_12[3] = ((long) (local3 + 32)); + callArgs_12[2] = ((long) 10799); + callArgs_12[1] = ((long) (local3 + 40)); + callArgs_12[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_12); + } + local7 = (local5 + 12); + local5 = (local5 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local10, local7) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break label_3; + } + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) 412); + long[] callResult_13 = instance.getMachine().call(1776, callArgs_13); + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) 400); + callArgs_14[1] = ((long) 0); + callArgs_14[0] = ((long) ((int) callResult_13[0])); + long[] callResult_14 = instance.getMachine().call(1892, callArgs_14); + local9 = ((int) callResult_14[0]); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) 49708); + local4 = (local9 + 8); + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) 224); + callArgs_15[1] = ((long) 0); + callArgs_15[0] = ((long) local4); + long[] callResult_15 = instance.getMachine().call(1892, callArgs_15); + local13 = ((int) callResult_15[0]); + memory.writeLong((int) (local9 + 236) < 0 ? (local9 + 236) : (local9 + 236) + 0, (long) 0L); + memory.writeI32((int) (local9 + 232) < 0 ? (local9 + 232) : (local9 + 232) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 244) < 0 ? (local9 + 244) : (local9 + 244) + 0, (long) 0L); + memory.writeLong((int) (local9 + 256) < 0 ? (local9 + 256) : (local9 + 256) + 0, (long) 0L); + memory.writeI32((int) (local9 + 252) < 0 ? (local9 + 252) : (local9 + 252) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 264) < 0 ? (local9 + 264) : (local9 + 264) + 0, (long) 0L); + memory.writeLong((int) (local9 + 276) < 0 ? (local9 + 276) : (local9 + 276) + 0, (long) 0L); + memory.writeI32((int) (local9 + 272) < 0 ? (local9 + 272) : (local9 + 272) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 284) < 0 ? (local9 + 284) : (local9 + 284) + 0, (long) 0L); + memory.writeLong((int) (local9 + 296) < 0 ? (local9 + 296) : (local9 + 296) + 0, (long) 0L); + memory.writeI32((int) (local9 + 292) < 0 ? (local9 + 292) : (local9 + 292) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 304) < 0 ? (local9 + 304) : (local9 + 304) + 0, (long) 0L); + memory.writeLong((int) (local9 + 316) < 0 ? (local9 + 316) : (local9 + 316) + 0, (long) 0L); + memory.writeI32((int) (local9 + 312) < 0 ? (local9 + 312) : (local9 + 312) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 324) < 0 ? (local9 + 324) : (local9 + 324) + 0, (long) 0L); + memory.writeI32((int) (local9 + 332) < 0 ? (local9 + 332) : (local9 + 332) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 336) < 0 ? (local9 + 336) : (local9 + 336) + 0, (long) 0L); + memory.writeLong((int) (local9 + 344) < 0 ? (local9 + 344) : (local9 + 344) + 0, (long) 0L); + memory.writeLong((int) (local9 + 356) < 0 ? (local9 + 356) : (local9 + 356) + 0, (long) 0L); + memory.writeI32((int) (local9 + 352) < 0 ? (local9 + 352) : (local9 + 352) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 364) < 0 ? (local9 + 364) : (local9 + 364) + 0, (long) 0L); + memory.writeI32((int) (local9 + 372) < 0 ? (local9 + 372) : (local9 + 372) + 0, (int) 1065353216); + memory.writeLong((int) (local9 + 376) < 0 ? (local9 + 376) : (local9 + 376) + 0, (long) 0L); + memory.writeLong((int) (local9 + 384) < 0 ? (local9 + 384) : (local9 + 384) + 0, (long) 0L); + local5 = (local9 + 404); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeI32((int) (local9 + 392) < 0 ? (local9 + 392) : (local9 + 392) + 0, (int) 1065353216); + memory.writeI32((int) (local9 + 400) < 0 ? (local9 + 400) : (local9 + 400) + 0, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 280, (int) 0); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 272, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 144, (int) 27450); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 148, (int) 6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 152, (int) 0); + local6 = memory.readInt((int) (local7 + 44) < 0 ? (local7 + 44) : (local7 + 44) + 0); + local5 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 136, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 144)); + long[] callArgs_16 = new long[4]; + callArgs_16[3] = ((long) (local3 + 272)); + callArgs_16[2] = ((long) (local6 - local5)); + callArgs_16[1] = ((long) local5); + callArgs_16[0] = ((long) (local3 + 136)); + long[] callResult_16 = instance.getMachine().call(556, callArgs_16); + local14 = ((int) callResult_16[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 180, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 172, (int) -1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 168, (int) local14); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 176, (int) (local3 + 272)); + long[] callArgs_17 = new long[3]; + callArgs_17[2] = ((long) 84); + callArgs_17[1] = ((long) 0); + callArgs_17[0] = ((long) ((local3 + 168) + 16)); + long[] callResult_17 = instance.getMachine().call(1892, callArgs_17); + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) (local3 + 152)); + callArgs_18[0] = ((long) (local3 + 168)); + long[] callResult_18 = instance.getMachine().call(1204, callArgs_18); + local15 = ((int) callResult_18[0]); + label_13: { + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 272); + local16 = memory.readInt((int) local3 < 0 ? local3 : local3 + 276); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local16, local5) != 0) { + break label_13; + } + local5 = (local5 + 24); + local6 = (local7 + 8); + label_14: while (true) { + label_15: { + label_16: { + local8 = (local5 + -12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) local8 < 0 ? local8 : local8 + 0)) != 0) { + break label_16; + } + local8 = (int) (byte) memory.read((int) (local5 + 11) < 0 ? (local5 + 11) : (local5 + 11) + 0); + local11 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + memory.writeI32((int) ((local3 + 72) + 16) < 0 ? ((local3 + 72) + 16) : ((local3 + 72) + 16) + 0, (int) memory.readInt((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) ((local3 + 72) + 8) < 0 ? ((local3 + 72) + 8) : ((local3 + 72) + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 72, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 64, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0) != 0 ? local11 : local5)); + long[] callArgs_19 = new long[4]; + callArgs_19[3] = ((long) (local3 + 64)); + callArgs_19[2] = ((long) 11071); + callArgs_19[1] = ((long) (local3 + 72)); + callArgs_19[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_19); + break label_15; + } + local11 = (int) (byte) memory.read((int) (local5 + 11) < 0 ? (local5 + 11) : (local5 + 11) + 0); + local10 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local8 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + memory.writeI32((int) ((local3 + 112) + 16) < 0 ? ((local3 + 112) + 16) : ((local3 + 112) + 16) + 0, (int) memory.readInt((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) ((local3 + 112) + 8) < 0 ? ((local3 + 112) + 8) : ((local3 + 112) + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + local12 = memory.readLong((int) local6 < 0 ? local6 : local6 + 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 96, (int) local8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 112, (long) local12); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 100, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local11, 0) != 0 ? local10 : local5)); + long[] callArgs_20 = new long[4]; + callArgs_20[3] = ((long) (local3 + 96)); + callArgs_20[2] = ((long) 10836); + callArgs_20[1] = ((long) (local3 + 112)); + callArgs_20[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_20); + } + local8 = (local5 + 12); + local5 = (local5 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local16, local8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + } + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local15) != 0) { + break label_17; + } + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 152)); + callArgs_21[0] = ((long) local13); + long[] callResult_21 = instance.getMachine().call(1206, callArgs_21); + } + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local9); + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_18; + } + int ciTableIdx_22 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_22 = instance.table(0).requiredRef(ciTableIdx_22); + com.dylibso.chicory.runtime.Instance ciRefInstance_22 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_22), instance); + if (!ciRefInstance_22.type(ciRefInstance_22.functionType(ciFuncId_22)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) local5); + ciRefInstance_22.getMachine().call(ciFuncId_22, callArgs_22); + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local14) != 0) { + break label_19; + } + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local14 < 0 ? local14 : local14 + 15), -1) != 0) { + break label_20; + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) memory.readInt((int) local14 < 0 ? local14 : local14 + 4)); + instance.getMachine().call(1777, callArgs_23); + } + local5 = memory.readInt((int) local14 < 0 ? local14 : local14 + 0); + memory.writeI32((int) local14 < 0 ? local14 : local14 + 0, (int) 0); + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_21; + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_24); + } + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) local14); + instance.getMachine().call(1777, callArgs_25); + } + label_22: { + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_22; + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) local5); + long[] callResult_26 = instance.getMachine().call(32, callArgs_26); + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) ((int) callResult_26[0])); + instance.getMachine().call(1777, callArgs_27); + } + local8 = memory.readInt((int) local3 < 0 ? local3 : local3 + 272); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_2; + } + local5 = local8; + label_23: { + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 276); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local8, local6) != 0) { + break label_23; + } + local5 = (local6 + -12); + label_24: while (true) { + label_25: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local5 + 11) < 0 ? (local5 + 11) : (local5 + 11) + 0), -1) != 0) { + break label_25; + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + instance.getMachine().call(1777, callArgs_28); + } + local6 = (local5 + -24); + local5 = (local5 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local8, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_24; + } + break; + } + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 272); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 276, (int) local8); + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_29); + break label_2; + } + local5 = memory.readInt((int) local8 < 0 ? local8 : local8 + 412); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 412, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 160)); + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_26; + } + int ciTableIdx_30 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_30 = instance.table(0).requiredRef(ciTableIdx_30); + com.dylibso.chicory.runtime.Instance ciRefInstance_30 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_30), instance); + if (!ciRefInstance_30.type(ciRefInstance_30.functionType(ciFuncId_30)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) local5); + ciRefInstance_30.getMachine().call(ciFuncId_30, callArgs_30); + } + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local8); + label_27: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_27; + } + int ciTableIdx_31 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_31 = instance.table(0).requiredRef(ciTableIdx_31); + com.dylibso.chicory.runtime.Instance ciRefInstance_31 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_31), instance); + if (!ciRefInstance_31.type(ciRefInstance_31.functionType(ciFuncId_31)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) local5); + ciRefInstance_31.getMachine().call(ciFuncId_31, callArgs_31); + } + label_28: { + local7 = memory.readInt((int) local3 < 0 ? local3 : local3 + 272); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_28; + } + local5 = local7; + label_29: { + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 276); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, local6) != 0) { + break label_29; + } + local5 = (local6 + -12); + label_30: while (true) { + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local5 + 11) < 0 ? (local5 + 11) : (local5 + 11) + 0), -1) != 0) { + break label_31; + } + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + instance.getMachine().call(1777, callArgs_32); + } + local6 = (local5 + -24); + local5 = (local5 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_30; + } + break; + } + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 272); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 276, (int) local7); + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_33); + } + local7 = 0; + } + label_32: { + if (arg1 != 0) { + break label_32; + } + local5 = 0; + break label_1; + } + local5 = 0; + local6 = ((memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) >> 2); + label_33: { + local8 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 31) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local8), 0) != 0 ? memory.readInt((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0) : local8)) != 0) { + break label_33; + } + memory.writeI32((int) ((local3 + 168) + 16) < 0 ? ((local3 + 168) + 16) : ((local3 + 168) + 16) + 0, (int) memory.readInt((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + memory.writeLong((int) ((local3 + 168) + 8) < 0 ? ((local3 + 168) + 8) : ((local3 + 168) + 8) + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 188, (int) local6); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 168, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + local8 = (arg1 + 12); + long[] callArgs_34 = new long[4]; + callArgs_34[3] = ((long) (local3 + 168)); + callArgs_34[2] = ((long) (local4 + 20)); + callArgs_34[1] = ((long) local8); + callArgs_34[0] = ((long) (local3 + 272)); + instance.getMachine().call(137, callArgs_34); + long[] callArgs_35 = new long[2]; + callArgs_35[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 272)); + callArgs_35[0] = ((long) local8); + long[] callResult_35 = instance.getMachine().call(138, callArgs_35); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + } + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_34; + } + int ciTableIdx_36 = (int) (memory.readInt((int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0) < 0 ? memory.readInt((int) local7 < 0 ? local7 : local7 + 0) : memory.readInt((int) local7 < 0 ? local7 : local7 + 0) + 4)); + int ciFuncId_36 = instance.table(0).requiredRef(ciTableIdx_36); + com.dylibso.chicory.runtime.Instance ciRefInstance_36 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_36), instance); + if (!ciRefInstance_36.type(ciRefInstance_36.functionType(ciFuncId_36)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) local7); + ciRefInstance_36.getMachine().call(ciFuncId_36, callArgs_36); + } + instance.global(0).setValue(((long) (local3 + 288))); + return local5; + } + + public static long[] call_1205(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1205(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1206(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + local2 = (arg1 + 20); + local3 = (arg0 + 20); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 31), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0)); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 31, (byte) (0)); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 20, (byte) (0)); + label_2: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + label_3: while (true) { + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local3 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 0); + local3 = (arg0 + 36); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32)); + local2 = (arg1 + 36); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 32, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + memory.writeLong((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0, (long) memory.readLong((int) (arg1 + 52) < 0 ? (arg1 + 52) : (arg1 + 52) + 0)); + memory.writeI32((int) (arg0 + 60) < 0 ? (arg0 + 60) : (arg0 + 60) + 0, (int) memory.readInt((int) (arg1 + 60) < 0 ? (arg1 + 60) : (arg1 + 60) + 0)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 44, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 44)); + label_4: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_4; + } + memory.writeI32((int) (arg0 + 68) < 0 ? (arg0 + 68) : (arg0 + 68) + 0, (int) local3); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_2); + memory.writeI32((int) (arg0 + 72) < 0 ? (arg0 + 72) : (arg0 + 72) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 64, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 64, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 64)); + local3 = (arg1 + 72); + memory.writeI32((int) (arg0 + 72) < 0 ? (arg0 + 72) : (arg0 + 72) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 64, (long) 0L); + label_5: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_5; + } + memory.writeI32((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0, (int) local3); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_3); + memory.writeI32((int) (arg0 + 84) < 0 ? (arg0 + 84) : (arg0 + 84) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 76, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 76, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 76)); + local3 = (arg1 + 84); + memory.writeI32((int) (arg0 + 84) < 0 ? (arg0 + 84) : (arg0 + 84) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 76, (long) 0L); + label_6: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_6; + } + memory.writeI32((int) (arg0 + 92) < 0 ? (arg0 + 92) : (arg0 + 92) + 0, (int) local3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_4); + memory.writeI32((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 88)); + local3 = (arg1 + 96); + memory.writeI32((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 88, (long) 0L); + label_7: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 100); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_7; + } + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) local3); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_5); + memory.writeI32((int) (arg0 + 108) < 0 ? (arg0 + 108) : (arg0 + 108) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 100, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 100, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 100)); + local3 = (arg1 + 108); + memory.writeI32((int) (arg0 + 108) < 0 ? (arg0 + 108) : (arg0 + 108) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 100, (long) 0L); + label_8: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 112); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_8; + } + memory.writeI32((int) (arg0 + 116) < 0 ? (arg0 + 116) : (arg0 + 116) + 0, (int) local3); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_6); + memory.writeI32((int) (arg0 + 120) < 0 ? (arg0 + 120) : (arg0 + 120) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 112, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 112, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 112)); + local3 = (arg1 + 120); + memory.writeI32((int) (arg0 + 120) < 0 ? (arg0 + 120) : (arg0 + 120) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 112, (long) 0L); + label_9: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_9; + } + memory.writeI32((int) (arg0 + 128) < 0 ? (arg0 + 128) : (arg0 + 128) + 0, (int) local3); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_7); + memory.writeI32((int) (arg0 + 132) < 0 ? (arg0 + 132) : (arg0 + 132) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 124, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 124, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 124)); + local3 = (arg1 + 132); + memory.writeI32((int) (arg0 + 132) < 0 ? (arg0 + 132) : (arg0 + 132) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 124, (long) 0L); + label_10: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 136); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_10; + } + memory.writeI32((int) (arg0 + 140) < 0 ? (arg0 + 140) : (arg0 + 140) + 0, (int) local3); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_8); + memory.writeI32((int) (arg0 + 144) < 0 ? (arg0 + 144) : (arg0 + 144) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 136, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 136, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 136)); + local3 = (arg1 + 144); + memory.writeI32((int) (arg0 + 144) < 0 ? (arg0 + 144) : (arg0 + 144) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 136, (long) 0L); + label_11: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 148); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_11; + } + memory.writeI32((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0, (int) local3); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_9); + memory.writeI32((int) (arg0 + 156) < 0 ? (arg0 + 156) : (arg0 + 156) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 148, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 148, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 148)); + local3 = (arg1 + 156); + memory.writeI32((int) (arg0 + 156) < 0 ? (arg0 + 156) : (arg0 + 156) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 148, (long) 0L); + label_12: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 160); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_12; + } + memory.writeI32((int) (arg0 + 164) < 0 ? (arg0 + 164) : (arg0 + 164) + 0, (int) local3); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_10); + memory.writeI32((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 160, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 160, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 160)); + local3 = (arg1 + 168); + memory.writeI32((int) (arg0 + 168) < 0 ? (arg0 + 168) : (arg0 + 168) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 160, (long) 0L); + label_13: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 172); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_13; + } + memory.writeI32((int) (arg0 + 176) < 0 ? (arg0 + 176) : (arg0 + 176) + 0, (int) local3); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_11); + memory.writeI32((int) (arg0 + 180) < 0 ? (arg0 + 180) : (arg0 + 180) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 172, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 172, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 172)); + local3 = (arg1 + 180); + memory.writeI32((int) (arg0 + 180) < 0 ? (arg0 + 180) : (arg0 + 180) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 172, (long) 0L); + label_14: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 184); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_14; + } + memory.writeI32((int) (arg0 + 188) < 0 ? (arg0 + 188) : (arg0 + 188) + 0, (int) local3); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_12); + memory.writeI32((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 184, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 184, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 184)); + local3 = (arg1 + 192); + memory.writeI32((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 184, (long) 0L); + label_15: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 196); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_15; + } + local3 = local4; + label_16: { + local2 = memory.readInt((int) (arg0 + 200) < 0 ? (arg0 + 200) : (arg0 + 200) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local2) != 0) { + break label_16; + } + local3 = (local2 + -44); + label_17: while (true) { + label_18: { + local2 = memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_18; + } + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local2); + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_13); + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local3 + 11) < 0 ? (local3 + 11) : (local3 + 11) + 0), -1) != 0) { + break label_19; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_14); + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3); + local3 = (local3 + -44); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_17; + } + break; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 196); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 200, (int) local4); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_15); + memory.writeI32((int) (arg0 + 204) < 0 ? (arg0 + 204) : (arg0 + 204) + 0, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 196, (long) 0L); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 196, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 196)); + local3 = (arg1 + 204); + memory.writeI32((int) (arg0 + 204) < 0 ? (arg0 + 204) : (arg0 + 204) + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 196, (long) 0L); + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) (arg1 + 208)); + callArgs_16[0] = ((long) (arg0 + 208)); + instance.getMachine().call(1210, callArgs_16); + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) (arg1 + 228)); + callArgs_17[0] = ((long) (arg0 + 228)); + instance.getMachine().call(1210, callArgs_17); + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) (arg1 + 248)); + callArgs_18[0] = ((long) (arg0 + 248)); + instance.getMachine().call(1210, callArgs_18); + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) (arg1 + 268)); + callArgs_19[0] = ((long) (arg0 + 268)); + instance.getMachine().call(1210, callArgs_19); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) (arg1 + 288)); + callArgs_20[0] = ((long) (arg0 + 288)); + instance.getMachine().call(1210, callArgs_20); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) (arg1 + 308)); + callArgs_21[0] = ((long) (arg0 + 308)); + instance.getMachine().call(1210, callArgs_21); + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) (arg1 + 328)); + callArgs_22[0] = ((long) (arg0 + 328)); + instance.getMachine().call(1210, callArgs_22); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) (arg1 + 348)); + callArgs_23[0] = ((long) (arg0 + 348)); + instance.getMachine().call(1210, callArgs_23); + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) (arg1 + 368)); + callArgs_24[0] = ((long) (arg0 + 368)); + instance.getMachine().call(1210, callArgs_24); + memory.writeByte((int) (arg0 + 390) < 0 ? (arg0 + 390) : (arg0 + 390) + 0, (byte) (((int) memory.read((int) (arg1 + 390) < 0 ? (arg1 + 390) : (arg1 + 390) + 0) & 0xFF))); + memory.writeShort((int) arg0 < 0 ? arg0 : arg0 + 388, (short) (((int) memory.readShort((int) arg1 < 0 ? arg1 : arg1 + 388) & 0xFFFF))); + local5 = (arg0 + 392); + local3 = (arg0 + 396); + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + callArgs_25[0] = ((long) local5); + instance.getMachine().call(34, callArgs_25); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 392, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 392)); + local4 = (arg1 + 396); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local6); + local2 = memory.readInt((int) (arg1 + 400) < 0 ? (arg1 + 400) : (arg1 + 400) + 0); + memory.writeI32((int) (arg0 + 400) < 0 ? (arg0 + 400) : (arg0 + 400) + 0, (int) local2); + label_20: { + if (local2 != 0) { + break label_20; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + return arg0; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local3); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 396, (long) 0L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 392, (int) local4); + return arg0; + } + + public static long[] call_1206(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1206(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1207(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + local2 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 16); + label_1: { + label_2: { + label_3: { + label_4: while (true) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + local5 = ((int) callResult_1[0]); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, local4) != 0) { + break label_6; + } + label_7: { + switch((local5 + -13)) { + case 0: + { + break label_5; + } + case 1: + { + break label_6; + } + case 2: + { + break label_6; + } + case 3: + { + break label_6; + } + case 4: + { + break label_6; + } + case 5: + { + break label_5; + } + case 6: + { + break label_6; + } + case 7: + { + break label_5; + } + case 8: + { + break label_5; + } + case 9: + { + break label_6; + } + case 10: + { + break label_6; + } + case 11: + { + break label_6; + } + case 12: + { + break label_5; + } + case 13: + { + break label_5; + } + case 14: + { + break label_6; + } + case 15: + { + break label_6; + } + case 16: + { + break label_6; + } + case 17: + { + break label_6; + } + case 18: + { + break label_5; + } + case 19: + { + break label_6; + } + case 20: + { + break label_6; + } + case 21: + { + break label_6; + } + case 22: + { + break label_6; + } + case 23: + { + break label_6; + } + case 24: + { + break label_6; + } + case 25: + { + break label_6; + } + case 26: + { + break label_6; + } + case 27: + { + break label_6; + } + case 28: + { + break label_6; + } + case 29: + { + break label_6; + } + case 30: + { + break label_6; + } + case 31: + { + break label_6; + } + case 32: + { + break label_6; + } + case 33: + { + break label_5; + } + case 34: + { + break label_6; + } + case 35: + { + break label_5; + } + case 36: + { + break label_6; + } + case 37: + { + break label_5; + } + default: + { + break label_7; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(138, local5) != 0) { + break label_5; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 11) & 0xFF)) != 0) { + break label_3; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1154, callArgs_2); + local4 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1154, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(132, local4) != 0) { + break label_3; + } + local4 = (local3 + (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF) * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + local6 = memory.readLong((int) local4 < 0 ? local4 : local4 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(25769803776L, (local6 & -4294967296L)) != 0) { + break label_3; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 6); + callArgs_4[1] = ((long) 13015); + callArgs_4[0] = ((long) (int) local6); + long[] callResult_4 = instance.getMachine().call(1889, callArgs_4); + if (((int) callResult_4[0]) != 0) { + break label_3; + } + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 11) & 0xFF)) != 0) { + break label_8; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 0); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + local4 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(132, local4) != 0) { + break label_8; + } + local4 = (local3 + (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF) * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + local6 = memory.readLong((int) local4 < 0 ? local4 : local4 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(25769803776L, (local6 & -4294967296L)) != 0) { + break label_8; + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 6); + callArgs_7[1] = ((long) 13015); + callArgs_7[0] = ((long) (int) local6); + long[] callResult_7 = instance.getMachine().call(1889, callArgs_7); + if (((int) callResult_7[0]) != 0) { + break label_8; + } + local4 = 1; + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1212, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_8[0])) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break label_2; + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) arg1); + callArgs_9[0] = ((long) arg0); + long[] callResult_9 = instance.getMachine().call(1213, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_9[0])) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + local4 = 1; + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) 667); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1161, callArgs_10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_10[0])) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break label_2; + } + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_9: { + local8 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_9; + } + local9 = (arg1 + 288); + local10 = 0; + label_10: while (true) { + label_11: { + label_12: { + label_13: { + label_14: { + label_15: { + switch(memory.readInt((int) local8 < 0 ? local8 : local8 + 32)) { + case 0: + { + break label_15; + } + case 1: + { + break label_11; + } + case 2: + { + break label_13; + } + case 3: + { + break label_11; + } + case 4: + { + break label_11; + } + case 5: + { + break label_11; + } + case 6: + { + break label_11; + } + case 7: + { + break label_11; + } + case 8: + { + break label_11; + } + case 9: + { + break label_11; + } + case 10: + { + break label_14; + } + default: + { + break label_11; + } + } + } + local3 = (local8 + 48); + local11 = (local8 + 36); + break label_12; + } + local3 = (local8 + 48); + local11 = 0; + break label_12; + } + label_16: { + local4 = memory.readInt((int) local8 < 0 ? local8 : local8 + 36); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 28); + if (local5 != 0) { + break label_16; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_16; + } + local3 = (local4 + 44); + local11 = 0; + break label_12; + } + local11 = 0; + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(4, local5) != 0 ? local4 : 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_11; + } + local3 = (local4 + 44); + } + label_17: { + local12 = memory.readInt((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local12) != 0) { + break label_17; + } + local5 = 0; + label_18: while (true) { + label_19: { + local13 = (local4 + (local5 << 3)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, memory.readInt((int) local13 < 0 ? local13 : local13 + 0)) != 0) { + break label_19; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) local13 < 0 ? local13 : local13 + 4)) != 0) { + break label_19; + } + local14 = 0; + label_20: { + local15 = memory.readInt((int) (local3 + 68) < 0 ? (local3 + 68) : (local3 + 68) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_20; + } + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 64); + label_21: { + label_22: { + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local12, 1) != 0) { + break label_22; + } + local16 = ((local15 + -1) & local5); + break label_21; + } + local16 = local5; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local15) != 0) { + break label_21; + } + local16 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local5, local15); + } + local4 = memory.readInt((int) (local4 + (local16 << 2)) < 0 ? (local4 + (local16 << 2)) : (local4 + (local16 << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_20; + } + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_20; + } + label_23: { + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local12, 2) != 0) { + break label_24; + } + local15 = (local15 + -1); + label_25: while (true) { + label_26: { + label_27: { + local12 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local12) != 0) { + break label_27; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local16, (local12 & local15)) != 0) { + break label_20; + } + break label_26; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, memory.readInt((int) local4 < 0 ? local4 : local4 + 8)) != 0) { + break label_23; + } + } + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_25; + } + break label_20; + } + } + label_28: while (true) { + label_29: { + label_30: { + local12 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local12) != 0) { + break label_30; + } + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local12, local15) != 0) { + break label_31; + } + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local12, local15); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local16, local12) != 0) { + break label_20; + } + break label_29; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, memory.readInt((int) local4 < 0 ? local4 : local4 + 8)) != 0) { + break label_23; + } + } + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_28; + } + break label_20; + } + } + local14 = local4; + } + label_32: { + label_33: { + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) (local14 + 12)); + callArgs_11[0] = ((long) local9); + long[] callResult_11 = instance.getMachine().call(120, callArgs_11); + local4 = ((int) callResult_11[0]); + if (local4 != 0) { + break label_33; + } + local6 = -21L; + break label_32; + } + local6 = ((((long) memory.readInt((int) (local4 + 40) < 0 ? (local4 + 40) : (local4 + 40) + 0) & 0xFFFFFFFFL) << 32L) | 4294967275L); + } + memory.writeLong((int) local13 < 0 ? local13 : local13 + 0, (long) local6); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 40); + local12 = memory.readInt((int) local3 < 0 ? local3 : local3 + 44); + } + local5 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, ((local12 - local4) >> 3)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + } + label_34: { + local12 = memory.readInt((int) (local3 + 56) < 0 ? (local3 + 56) : (local3 + 56) + 0); + local4 = memory.readInt((int) (local3 + 52) < 0 ? (local3 + 52) : (local3 + 52) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local12) != 0) { + break label_34; + } + local5 = 0; + label_35: while (true) { + label_36: { + local13 = (local4 + (local5 << 3)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, memory.readInt((int) local13 < 0 ? local13 : local13 + 0)) != 0) { + break label_36; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) local13 < 0 ? local13 : local13 + 4)) != 0) { + break label_36; + } + local14 = 0; + label_37: { + local15 = memory.readInt((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_37; + } + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 84); + label_38: { + label_39: { + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local12, 1) != 0) { + break label_39; + } + local16 = ((local15 + -1) & local5); + break label_38; + } + local16 = local5; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, local15) != 0) { + break label_38; + } + local16 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local5, local15); + } + local4 = memory.readInt((int) (local4 + (local16 << 2)) < 0 ? (local4 + (local16 << 2)) : (local4 + (local16 << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_37; + } + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_37; + } + label_40: { + label_41: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local12, 2) != 0) { + break label_41; + } + local15 = (local15 + -1); + label_42: while (true) { + label_43: { + label_44: { + local12 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local12) != 0) { + break label_44; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local16, (local12 & local15)) != 0) { + break label_37; + } + break label_43; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, memory.readInt((int) local4 < 0 ? local4 : local4 + 8)) != 0) { + break label_40; + } + } + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_42; + } + break label_37; + } + } + label_45: while (true) { + label_46: { + label_47: { + local12 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local12) != 0) { + break label_47; + } + label_48: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local12, local15) != 0) { + break label_48; + } + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local12, local15); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local16, local12) != 0) { + break label_37; + } + break label_46; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, memory.readInt((int) local4 < 0 ? local4 : local4 + 8)) != 0) { + break label_40; + } + } + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_45; + } + break label_37; + } + } + local14 = local4; + } + label_49: { + label_50: { + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) (local14 + 12)); + callArgs_12[0] = ((long) local9); + long[] callResult_12 = instance.getMachine().call(120, callArgs_12); + local4 = ((int) callResult_12[0]); + if (local4 != 0) { + break label_50; + } + local6 = -21L; + break label_49; + } + local6 = ((((long) memory.readInt((int) (local4 + 40) < 0 ? (local4 + 40) : (local4 + 40) + 0) & 0xFFFFFFFFL) << 32L) | 4294967275L); + } + memory.writeLong((int) local13 < 0 ? local13 : local13 + 0, (long) local6); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 52); + local12 = memory.readInt((int) local3 < 0 ? local3 : local3 + 56); + } + local5 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, ((local12 - local4) >> 3)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_35; + } + break; + } + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) local3); + callArgs_13[0] = ((long) arg1); + long[] callResult_13 = instance.getMachine().call(1214, callArgs_13); + local5 = ((int) callResult_13[0]); + local4 = (local8 + 12); + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) local3); + callArgs_14[1] = ((long) arg1); + callArgs_14[0] = ((long) local4); + instance.getMachine().call(1215, callArgs_14); + long[] callArgs_15 = new long[4]; + callArgs_15[3] = ((long) local7); + callArgs_15[2] = ((long) local3); + callArgs_15[1] = ((long) arg1); + callArgs_15[0] = ((long) local4); + long[] callResult_15 = instance.getMachine().call(1216, callArgs_15); + local10 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local10) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_15[0]))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_11; + } + label_51: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_51; + } + local4 = memory.readInt((int) (local11 + 136) < 0 ? (local11 + 136) : (local11 + 136) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_51; + } + local3 = ((memory.readInt((int) (local11 + 56) < 0 ? (local11 + 56) : (local11 + 56) + 0) - memory.readInt((int) (local11 + 52) < 0 ? (local11 + 52) : (local11 + 52) + 0)) >> 3); + label_52: while (true) { + local5 = (local4 + 40); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + local3)); + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_52; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 72, (int) local7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 68, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 64, (int) 48236); + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) (local2 + 64)); + callArgs_16[0] = ((long) (local2 + 8)); + long[] callResult_16 = instance.getMachine().call(447, callArgs_16); + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) local11); + callArgs_17[0] = ((long) ((int) callResult_16[0])); + long[] callResult_17 = instance.getMachine().call(454, callArgs_17); + local5 = ((int) callResult_17[0]); + label_53: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_53; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 52, (int) local4); + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_18); + } + label_54: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_54; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) local4); + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_19); + } + label_55: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_55; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) local4); + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_20); + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5); + label_56: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_56; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local4); + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_21); + } + local10 = (local10 | local5); + } + local8 = memory.readInt((int) local8 < 0 ? local8 : local8 + 4); + if (local8 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + local4 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local10) != 0) { + break label_2; + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + } + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) local7); + callArgs_22[0] = ((long) arg1); + long[] callResult_22 = instance.getMachine().call(1097, callArgs_22); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_22[0])); + } + instance.global(0).setValue(((long) (local2 + 80))); + return local4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1207(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1207(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1208(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local4), 36); + local6 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 119304648) != 0) { + break label_4; + } + label_5: { + label_6: { + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local4), 36); + local7 = (local4 << 1); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, local6) != 0 ? local7 : local6) : 119304647); + if (local8 != 0) { + break label_6; + } + local4 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, 119304648) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local8 * 36)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local4 = ((int) callResult_0[0]); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg3); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + local6 = ((int) callResult_1[0]); + local7 = (local4 + (local5 * 36)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (local7 + 12) < 0 ? (local7 + 12) : (local7 + 12) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (int) memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 2147483632) != 0) { + break label_4; + } + local8 = (local8 * 36); + arg2 = (local7 + 24); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 10) != 0) { + break label_8; + } + memory.writeByte((int) local7 < 0 ? local7 : local7 + 35, (byte) (local6)); + break label_7; + } + local9 = ((local6 | 15) + 1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local9); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg1 = ((int) callResult_2[0]); + local5 = (local4 + (local5 * 36)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) (local9 | -2147483648)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg1); + memory.writeI32((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (int) local6); + arg2 = arg1; + } + local5 = (local4 + local8); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local6); + callArgs_3[1] = ((long) arg3); + callArgs_3[0] = ((long) arg2); + long[] callResult_3 = instance.getMachine().call(1891, callArgs_3); + memory.writeByte((int) (((int) callResult_3[0]) + local6) < 0 ? (((int) callResult_3[0]) + local6) : (((int) callResult_3[0]) + local6) + 0, (byte) (0)); + arg1 = (local7 + 36); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + arg3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg3, local4) != 0) { + break label_2; + } + label_9: while (true) { + arg2 = (local7 + -36); + local6 = (local4 + -36); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0, (long) memory.readLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + local7 = (local7 + -12); + local4 = (local4 + -12); + local8 = (local4 + 8); + memory.writeI32((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) 0L); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) 0); + local4 = local6; + local7 = arg2; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg3, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local6) != 0) { + break label_1; + } + local6 = (local6 + -12); + label_10: while (true) { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local6 + 11) < 0 ? (local6 + 11) : (local6 + 11) + 0), -1) != 0) { + break label_11; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + instance.getMachine().call(1777, callArgs_4); + } + arg2 = (local6 + -24); + local6 = (local6 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_12; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_7); + } + return; + } + + public static long[] call_1208(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1208(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_1209(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + label_2: { + local4 = (arg0 + 16); + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 72)); + instance.getMachine().call(557, callArgs_1); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 72) + 24) < 0 ? ((local2 + 72) + 24) : ((local2 + 72) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 72) + 32) < 0 ? ((local2 + 72) + 32) : ((local2 + 72) + 32) + 0)); + label_3: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + local3 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + } + label_4: { + label_5: { + label_6: { + label_7: { + local3 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_7; + } + memory.writeLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeI32((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + local3 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 32); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1160, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_1; + } + memory.writeI32((int) ((local2 + 56) + 8) < 0 ? ((local2 + 56) + 8) : ((local2 + 56) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) 0L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 56)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1165, callArgs_3); + label_8: { + label_9: { + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 0); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1154, callArgs_4); + local3 = ((int) callResult_4[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(41, local3) != 0) { + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(11, local3) != 0) { + break label_8; + } + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_7; + } + memory.writeByte((int) (local5 + 36) < 0 ? (local5 + 36) : (local5 + 36) + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) 0L); + label_10: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local2 + 40)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1183, callArgs_5); + local4 = ((int) callResult_5[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_10; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) 52); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + local3 = ((int) callResult_6[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 58364); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) 1); + memory.writeLong((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (long) 0L); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeLong((int) (local3 + 32) < 0 ? (local3 + 32) : (local3 + 32) + 0, (long) 0L); + memory.writeLong((int) (local3 + 40) < 0 ? (local3 + 40) : (local3 + 40) + 0, (long) 0L); + memory.writeI32((int) (local3 + 48) < 0 ? (local3 + 48) : (local3 + 48) + 0, (int) 0); + local6 = (local3 + 28); + local5 = (local3 + 8); + label_11: { + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), 0) != 0) { + break label_12; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + memory.writeI32((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (int) memory.readInt((int) ((local2 + 56) + 8) < 0 ? ((local2 + 56) + 8) : ((local2 + 56) + 8) + 0)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0)); + memory.writeI32((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (int) memory.readInt((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0)); + break label_11; + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 60)); + callArgs_7[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 56)); + callArgs_7[0] = ((long) local6); + long[] callResult_7 = instance.getMachine().call(1659, callArgs_7); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0)); + memory.writeI32((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (int) memory.readInt((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0)); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_11; + } + memory.writeI32((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (int) local5); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_8); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 40)); + memory.writeLong((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 44)); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) 0L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_5; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local5); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + label_13: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_13; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 44, (int) local3); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_10); + } + local3 = 1; + if (local4 != 0) { + break label_5; + } + break label_4; + } + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_7; + } + memory.writeByte((int) (local5 + 36) < 0 ? (local5 + 36) : (local5 + 36) + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) 0L); + label_14: { + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) (local2 + 40)); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1183, callArgs_11); + local4 = ((int) callResult_11[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_14; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) 52); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + local3 = ((int) callResult_12[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 58548); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) 2); + memory.writeLong((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (long) 0L); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) 0L); + memory.writeLong((int) (local3 + 32) < 0 ? (local3 + 32) : (local3 + 32) + 0, (long) 0L); + memory.writeLong((int) (local3 + 40) < 0 ? (local3 + 40) : (local3 + 40) + 0, (long) 0L); + memory.writeI32((int) (local3 + 48) < 0 ? (local3 + 48) : (local3 + 48) + 0, (int) 0); + local6 = (local3 + 28); + local5 = (local3 + 8); + label_15: { + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), 0) != 0) { + break label_16; + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + memory.writeI32((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (int) memory.readInt((int) ((local2 + 56) + 8) < 0 ? ((local2 + 56) + 8) : ((local2 + 56) + 8) + 0)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0)); + memory.writeI32((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (int) memory.readInt((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0)); + break label_15; + } + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 60)); + callArgs_13[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 56)); + callArgs_13[0] = ((long) local6); + long[] callResult_13 = instance.getMachine().call(1659, callArgs_13); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0)); + memory.writeI32((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (int) memory.readInt((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0)); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_15; + } + memory.writeI32((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (int) local5); + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local5); + instance.getMachine().call(1777, callArgs_14); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 40)); + memory.writeLong((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 44)); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) 0L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_5; + } + int ciTableIdx_15 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_15 = instance.table(0).requiredRef(ciTableIdx_15); + com.dylibso.chicory.runtime.Instance ciRefInstance_15 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_15), instance); + if (!ciRefInstance_15.type(ciRefInstance_15.functionType(ciFuncId_15)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local5); + ciRefInstance_15.getMachine().call(ciFuncId_15, callArgs_15); + } + label_17: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 44, (int) local3); + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_16); + } + local3 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + break label_5; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) 412); + long[] callResult_17 = instance.getMachine().call(1776, callArgs_17); + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) 400); + callArgs_18[1] = ((long) 0); + callArgs_18[0] = ((long) ((int) callResult_17[0])); + long[] callResult_18 = instance.getMachine().call(1892, callArgs_18); + local5 = ((int) callResult_18[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 58700); + long[] callArgs_19 = new long[3]; + callArgs_19[2] = ((long) 224); + callArgs_19[1] = ((long) 0); + callArgs_19[0] = ((long) (local5 + 8)); + long[] callResult_19 = instance.getMachine().call(1892, callArgs_19); + local6 = ((int) callResult_19[0]); + memory.writeLong((int) (local5 + 236) < 0 ? (local5 + 236) : (local5 + 236) + 0, (long) 0L); + memory.writeI32((int) (local5 + 232) < 0 ? (local5 + 232) : (local5 + 232) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 244) < 0 ? (local5 + 244) : (local5 + 244) + 0, (long) 0L); + memory.writeLong((int) (local5 + 256) < 0 ? (local5 + 256) : (local5 + 256) + 0, (long) 0L); + memory.writeI32((int) (local5 + 252) < 0 ? (local5 + 252) : (local5 + 252) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 264) < 0 ? (local5 + 264) : (local5 + 264) + 0, (long) 0L); + memory.writeLong((int) (local5 + 276) < 0 ? (local5 + 276) : (local5 + 276) + 0, (long) 0L); + memory.writeI32((int) (local5 + 272) < 0 ? (local5 + 272) : (local5 + 272) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 284) < 0 ? (local5 + 284) : (local5 + 284) + 0, (long) 0L); + memory.writeLong((int) (local5 + 296) < 0 ? (local5 + 296) : (local5 + 296) + 0, (long) 0L); + memory.writeI32((int) (local5 + 292) < 0 ? (local5 + 292) : (local5 + 292) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 304) < 0 ? (local5 + 304) : (local5 + 304) + 0, (long) 0L); + memory.writeLong((int) (local5 + 316) < 0 ? (local5 + 316) : (local5 + 316) + 0, (long) 0L); + memory.writeI32((int) (local5 + 312) < 0 ? (local5 + 312) : (local5 + 312) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 324) < 0 ? (local5 + 324) : (local5 + 324) + 0, (long) 0L); + memory.writeI32((int) (local5 + 332) < 0 ? (local5 + 332) : (local5 + 332) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 336) < 0 ? (local5 + 336) : (local5 + 336) + 0, (long) 0L); + memory.writeLong((int) (local5 + 344) < 0 ? (local5 + 344) : (local5 + 344) + 0, (long) 0L); + memory.writeLong((int) (local5 + 356) < 0 ? (local5 + 356) : (local5 + 356) + 0, (long) 0L); + memory.writeI32((int) (local5 + 352) < 0 ? (local5 + 352) : (local5 + 352) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 364) < 0 ? (local5 + 364) : (local5 + 364) + 0, (long) 0L); + memory.writeI32((int) (local5 + 372) < 0 ? (local5 + 372) : (local5 + 372) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 376) < 0 ? (local5 + 376) : (local5 + 376) + 0, (long) 0L); + memory.writeLong((int) (local5 + 384) < 0 ? (local5 + 384) : (local5 + 384) + 0, (long) 0L); + local3 = (local5 + 404); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + memory.writeI32((int) (local5 + 392) < 0 ? (local5 + 392) : (local5 + 392) + 0, (int) 1065353216); + memory.writeI32((int) (local5 + 400) < 0 ? (local5 + 400) : (local5 + 400) + 0, (int) local3); + local3 = (local5 + 28); + label_18: { + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), 0) != 0) { + break label_19; + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) ((local2 + 56) + 8) < 0 ? ((local2 + 56) + 8) : ((local2 + 56) + 8) + 0)); + break label_18; + } + long[] callArgs_20 = new long[3]; + callArgs_20[2] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 60)); + callArgs_20[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 56)); + callArgs_20[0] = ((long) local3); + long[] callResult_20 = instance.getMachine().call(1659, callArgs_20); + } + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 72)); + memory.writeI32((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (int) memory.readInt((int) ((local2 + 72) + 16) < 0 ? ((local2 + 72) + 16) : ((local2 + 72) + 16) + 0)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0)); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) 0); + callArgs_21[0] = ((long) arg0); + long[] callResult_21 = instance.getMachine().call(1154, callArgs_21); + local3 = ((int) callResult_21[0]); + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) 1); + callArgs_22[0] = ((long) arg0); + long[] callResult_22 = instance.getMachine().call(1154, callArgs_22); + local7 = ((int) callResult_22[0]); + label_20: { + label_21: { + label_22: { + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, local3) != 0) { + break label_23; + } + label_24: { + switch((local7 + -13)) { + case 0: + { + break label_22; + } + case 1: + { + break label_23; + } + case 2: + { + break label_23; + } + case 3: + { + break label_23; + } + case 4: + { + break label_23; + } + case 5: + { + break label_22; + } + case 6: + { + break label_23; + } + case 7: + { + break label_22; + } + case 8: + { + break label_22; + } + case 9: + { + break label_23; + } + case 10: + { + break label_23; + } + case 11: + { + break label_23; + } + case 12: + { + break label_22; + } + case 13: + { + break label_22; + } + case 14: + { + break label_23; + } + case 15: + { + break label_23; + } + case 16: + { + break label_23; + } + case 17: + { + break label_23; + } + case 18: + { + break label_22; + } + case 19: + { + break label_23; + } + case 20: + { + break label_23; + } + case 21: + { + break label_23; + } + case 22: + { + break label_23; + } + case 23: + { + break label_23; + } + case 24: + { + break label_23; + } + case 25: + { + break label_23; + } + case 26: + { + break label_23; + } + case 27: + { + break label_23; + } + case 28: + { + break label_23; + } + case 29: + { + break label_23; + } + case 30: + { + break label_23; + } + case 31: + { + break label_23; + } + case 32: + { + break label_23; + } + case 33: + { + break label_22; + } + case 34: + { + break label_23; + } + case 35: + { + break label_22; + } + case 36: + { + break label_23; + } + case 37: + { + break label_22; + } + default: + { + break label_24; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(138, local7) != 0) { + break label_22; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 11) & 0xFF)) != 0) { + break label_21; + } + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) 0); + callArgs_23[0] = ((long) arg0); + long[] callResult_23 = instance.getMachine().call(1154, callArgs_23); + local3 = ((int) callResult_23[0]); + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) 1); + callArgs_24[0] = ((long) arg0); + long[] callResult_24 = instance.getMachine().call(1154, callArgs_24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(132, local3) != 0) { + break label_21; + } + local3 = (local4 + (((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF) * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_7; + } + local8 = memory.readLong((int) local3 < 0 ? local3 : local3 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(25769803776L, (local8 & -4294967296L)) != 0) { + break label_21; + } + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) 6); + callArgs_25[1] = ((long) 13015); + callArgs_25[0] = ((long) (int) local8); + long[] callResult_25 = instance.getMachine().call(1889, callArgs_25); + if (((int) callResult_25[0]) != 0) { + break label_21; + } + } + local3 = 1; + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) local6); + callArgs_26[0] = ((long) arg0); + long[] callResult_26 = instance.getMachine().call(1207, callArgs_26); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_26[0])) != 0) { + break label_20; + } + break label_6; + } + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) 0); + callArgs_27[0] = ((long) arg0); + long[] callResult_27 = instance.getMachine().call(1154, callArgs_27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(44, ((int) callResult_27[0])) != 0) { + break label_6; + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) arg0); + instance.getMachine().call(1217, callArgs_28); + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) 17885); + callArgs_29[0] = ((long) (local2 + 16)); + long[] callResult_29 = instance.getMachine().call(1167, callArgs_29); + local4 = ((int) callResult_29[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) 1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) local4); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 32)); + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) (local2 + 8)); + callArgs_30[0] = ((long) (local2 + 40)); + long[] callResult_30 = instance.getMachine().call(1168, callArgs_30); + arg1 = ((int) callResult_30[0]); + long[] callArgs_31 = new long[3]; + callArgs_31[2] = ((long) 0); + callArgs_31[1] = ((long) arg1); + callArgs_31[0] = ((long) arg0); + long[] callResult_31 = instance.getMachine().call(1163, callArgs_31); + local3 = ((int) callResult_31[0]); + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) arg1); + long[] callResult_32 = instance.getMachine().call(1169, callArgs_32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_20; + } + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_33); + } + int ciTableIdx_34 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_34 = instance.table(0).requiredRef(ciTableIdx_34); + com.dylibso.chicory.runtime.Instance ciRefInstance_34 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_34), instance); + if (!ciRefInstance_34.type(ciRefInstance_34.functionType(ciFuncId_34)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) local5); + ciRefInstance_34.getMachine().call(ciFuncId_34, callArgs_34); + break label_4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_5; + } + int ciTableIdx_36 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_36 = instance.table(0).requiredRef(ciTableIdx_36); + com.dylibso.chicory.runtime.Instance ciRefInstance_36 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_36), instance); + if (!ciRefInstance_36.type(ciRefInstance_36.functionType(ciFuncId_36)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) local3); + ciRefInstance_36.getMachine().call(ciFuncId_36, callArgs_36); + } + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) 44); + callArgs_37[0] = ((long) arg0); + long[] callResult_37 = instance.getMachine().call(1160, callArgs_37); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_37[0])); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 67), -1) != 0) { + break label_1; + } + long[] callArgs_38 = new long[1]; + callArgs_38[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 56)); + instance.getMachine().call(1777, callArgs_38); + } + instance.global(0).setValue(((long) (local2 + 112))); + return local3; + } + + public static long[] call_1209(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1209(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1210(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)) != 0) { + break label_1; + } + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + label_3: while (true) { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 19), -1) != 0) { + break label_4; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + local2 = local3; + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + local4 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) 0); + label_5: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_5; + } + local3 = (local2 & 3); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 4) != 0) { + break label_6; + } + local5 = (local2 & -4); + local2 = 8; + local4 = 0; + label_7: while (true) { + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + -8) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + -8) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + -8) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + -4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + -4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + -4) + 0, (int) 0); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + 4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + 4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + 4) + 0, (int) 0); + local2 = (local2 + 16); + local4 = (local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_5; + } + local2 = (local4 << 2); + label_8: while (true) { + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local2) + 0, (int) 0); + local2 = (local2 + 4); + local3 = (local3 + -1); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) 0); + } + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local3); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_9; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) 0); + memory.writeF32((int) arg0 < 0 ? arg0 : arg0 + 16, (float) memory.readFloat((int) arg1 < 0 ? arg1 : arg1 + 16)); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local3); + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local2); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_10; + } + local4 = (arg0 + 8); + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + label_11: { + label_12: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = (local3 + -1); + if ((local3 & local5) != 0) { + break label_12; + } + local2 = (local5 & local2); + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, local3) != 0) { + break label_11; + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local2, local3); + } + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local2 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local2 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local2 << 2)) + 0, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 12, (int) 0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) 0); + } + return; + } + + public static long[] call_1210(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1210(arg0, arg1, memory, instance); + return null; + } + + public static int func_1211(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)) != 0) { + break label_1; + } + local1 = 1; + label_2: { + label_3: { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + switch((arg0 + -13)) { + case 0: + { + break label_1; + } + case 1: + { + break label_2; + } + case 2: + { + break label_2; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_1; + } + case 6: + { + break label_2; + } + case 7: + { + break label_1; + } + case 8: + { + break label_1; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_2; + } + case 12: + { + break label_1; + } + case 13: + { + break label_1; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_1; + } + case 19: + { + break label_2; + } + case 20: + { + break label_2; + } + case 21: + { + break label_2; + } + case 22: + { + break label_2; + } + case 23: + { + break label_2; + } + case 24: + { + break label_2; + } + case 25: + { + break label_2; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_2; + } + case 29: + { + break label_2; + } + case 30: + { + break label_2; + } + case 31: + { + break label_2; + } + case 32: + { + break label_2; + } + case 33: + { + break label_1; + } + case 34: + { + break label_2; + } + case 35: + { + break label_1; + } + case 36: + { + break label_2; + } + case 37: + { + break label_1; + } + default: + { + break label_3; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(138, arg0) != 0) { + break label_1; + } + } + local1 = 0; + } + return local1; + } + + public static long[] call_1211(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1211(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1212(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[11]; + long[] lL = new long[1]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = (((int) instance.global(0).getValue()) - 208); + instance.global(0).setValue(((long) iL[2])); + label_1: { + iL[3] = (iL[0] + 16); + iL[4] = ((int) memory.read((int) (iL[0] + 96) < 0 ? (iL[0] + 96) : (iL[0] + 96) + 0) & 0xFF); + if (((int) memory.read((int) (iL[3] + (iL[4] * 40)) < 0 ? (iL[3] + (iL[4] * 40)) : (iL[3] + (iL[4] * 40)) + 36) & 0xFF) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + callArgs_0[0] = ((long) (iL[2] + 8)); + instance.getMachine().call(557, callArgs_0); + iL[4] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[5] = (iL[3] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) * 40)); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 8)); + memory.writeLong((int) (iL[5] + 8) < 0 ? (iL[5] + 8) : (iL[5] + 8) + 0, (long) memory.readLong((int) ((iL[2] + 8) + 8) < 0 ? ((iL[2] + 8) + 8) : ((iL[2] + 8) + 8) + 0)); + memory.writeLong((int) (iL[5] + 16) < 0 ? (iL[5] + 16) : (iL[5] + 16) + 0, (long) memory.readLong((int) ((iL[2] + 8) + 16) < 0 ? ((iL[2] + 8) + 16) : ((iL[2] + 8) + 16) + 0)); + memory.writeLong((int) (iL[5] + 24) < 0 ? (iL[5] + 24) : (iL[5] + 24) + 0, (long) memory.readLong((int) ((iL[2] + 8) + 24) < 0 ? ((iL[2] + 8) + 24) : ((iL[2] + 8) + 24) + 0)); + memory.writeI32((int) (iL[5] + 32) < 0 ? (iL[5] + 32) : (iL[5] + 32) + 0, (int) memory.readInt((int) ((iL[2] + 8) + 32) < 0 ? ((iL[2] + 8) + 32) : ((iL[2] + 8) + 32) + 0)); + label_2: { + if (((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF) != 0) { + break label_2; + } + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 36, (byte) (1)); + } + if (((int) memory.read((int) (iL[3] + (iL[4] * 40)) < 0 ? (iL[3] + (iL[4] * 40)) : (iL[3] + (iL[4] * 40)) + 36) & 0xFF) != 0) { + break label_1; + } + iL[4] = (iL[4] ^ 1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[4])); + } + label_3: { + label_4: { + iL[5] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + break label_4; + } + memory.writeLong((int) ((iL[2] + 184) + 8) < 0 ? ((iL[2] + 184) + 8) : ((iL[2] + 184) + 8) + 0, (long) memory.readLong((int) (iL[5] + 8) < 0 ? (iL[5] + 8) : (iL[5] + 8) + 0)); + memory.writeI32((int) ((iL[2] + 184) + 16) < 0 ? ((iL[2] + 184) + 16) : ((iL[2] + 184) + 16) + 0, (int) memory.readInt((int) (iL[5] + 16) < 0 ? (iL[5] + 16) : (iL[5] + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 184, (long) memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[5] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + break label_4; + } + iL[6] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 36, (byte) (0)); + label_5: { + lL[0] = memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(25769803776L, (lL[0] & -4294967296L)) != 0) { + break label_5; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 6); + callArgs_1[1] = ((long) 13015); + callArgs_1[0] = ((long) (int) lL[0]); + long[] callResult_1 = instance.getMachine().call(1889, callArgs_1); + if (((int) callResult_1[0]) != 0) { + break label_5; + } + memory.writeI32((int) (iL[2] + 176) < 0 ? (iL[2] + 176) : (iL[2] + 176) + 0, (int) 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 168, (long) 0L); + iL[6] = 1; + label_6: { + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 1); + callArgs_2[1] = ((long) (iL[2] + 168)); + callArgs_2[0] = ((long) iL[0]); + long[] callResult_2 = instance.getMachine().call(1196, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_6; + } + label_7: { + label_8: { + int _d0 = func_1212__h0(iL, lL, memory, instance); + if (_d0 == 1) + break label_4; + if (_d0 == 2) + break label_6; + if (_d0 == 3) + break label_7; + if (_d0 == 4) + break label_3; + } + iL[5] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[7], 0); + iL[4] = (iL[5] != 0 ? iL[8] : (iL[7] & 255)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[4], 2147483632) != 0) { + break label_3; + } + iL[3] = (iL[5] != 0 ? iL[9] : (iL[2] + 168)); + label_31: { + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[4], 10) != 0) { + break label_32; + } + memory.writeByte((int) iL[2] < 0 ? iL[2] : iL[2] + 19, (byte) (iL[4])); + iL[5] = (iL[2] + 8); + break label_31; + } + iL[7] = ((iL[4] | 15) + 1); + long[] callArgs_43 = new long[1]; + callArgs_43[0] = ((long) iL[7]); + long[] callResult_43 = instance.getMachine().call(1776, callArgs_43); + iL[5] = ((int) callResult_43[0]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 16, (int) (iL[7] | -2147483648)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 8, (int) iL[5]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 12, (int) iL[4]); + } + long[] callArgs_44 = new long[3]; + callArgs_44[2] = ((long) iL[4]); + callArgs_44[1] = ((long) iL[3]); + callArgs_44[0] = ((long) iL[5]); + long[] callResult_44 = instance.getMachine().call(1891, callArgs_44); + memory.writeByte((int) (((int) callResult_44[0]) + iL[4]) < 0 ? (((int) callResult_44[0]) + iL[4]) : (((int) callResult_44[0]) + iL[4]) + 0, (byte) (0)); + memory.writeI32((int) (iL[2] + 28) < 0 ? (iL[2] + 28) : (iL[2] + 28) + 0, (int) 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 20, (long) 0L); + label_33: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[6], iL[0]) != 0) { + break label_33; + } + iL[0] = (iL[0] - iL[6]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[0], -1) != 0) { + break label_3; + } + long[] callArgs_45 = new long[1]; + callArgs_45[0] = ((long) iL[0]); + long[] callResult_45 = instance.getMachine().call(1776, callArgs_45); + iL[4] = ((int) callResult_45[0]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 20, (int) iL[4]); + iL[5] = (iL[4] + iL[0]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 28, (int) iL[5]); + long[] callArgs_46 = new long[3]; + callArgs_46[2] = ((long) iL[0]); + callArgs_46[1] = ((long) iL[6]); + callArgs_46[0] = ((long) iL[4]); + long[] callResult_46 = instance.getMachine().call(1890, callArgs_46); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 24, (int) iL[5]); + } + memory.writeI32((int) (iL[2] + 48) < 0 ? (iL[2] + 48) : (iL[2] + 48) + 0, (int) memory.readInt((int) (iL[2] + 200) < 0 ? (iL[2] + 200) : (iL[2] + 200) + 0)); + memory.writeLong((int) (iL[2] + 40) < 0 ? (iL[2] + 40) : (iL[2] + 40) + 0, (long) memory.readLong((int) (iL[2] + 192) < 0 ? (iL[2] + 192) : (iL[2] + 192) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 32, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 184)); + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_34; + } + long[] callArgs_47 = new long[1]; + callArgs_47[0] = ((long) iL[6]); + instance.getMachine().call(1777, callArgs_47); + } + label_35: { + label_36: { + iL[3] = memory.readInt((int) (iL[1] + 200) < 0 ? (iL[1] + 200) : (iL[1] + 200) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (iL[1] + 204) < 0 ? (iL[1] + 204) : (iL[1] + 204) + 0), iL[3]) != 0) { + break label_36; + } + label_37: { + label_38: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[2] < 0 ? iL[2] : iL[2] + 19), 0) != 0) { + break label_38; + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 8)); + memory.writeI32((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0, (int) memory.readInt((int) ((iL[2] + 8) + 8) < 0 ? ((iL[2] + 8) + 8) : ((iL[2] + 8) + 8) + 0)); + break label_37; + } + long[] callArgs_48 = new long[3]; + callArgs_48[2] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 12)); + callArgs_48[1] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 8)); + callArgs_48[0] = ((long) iL[3]); + instance.getMachine().call(1647, callArgs_48); + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (long) 0L); + memory.writeI32((int) (iL[3] + 20) < 0 ? (iL[3] + 20) : (iL[3] + 20) + 0, (int) 0); + label_39: { + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 24); + iL[0] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[0], iL[7]) != 0) { + break label_39; + } + iL[4] = (iL[7] - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[4], -1) != 0) { + break label_3; + } + long[] callArgs_49 = new long[1]; + callArgs_49[0] = ((long) iL[4]); + long[] callResult_49 = instance.getMachine().call(1776, callArgs_49); + iL[0] = ((int) callResult_49[0]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[0]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[0]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 20, (int) (iL[0] + iL[4])); + label_40: { + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 20); + iL[6] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[6], iL[7]) != 0) { + break label_40; + } + iL[8] = ((iL[7] ^ -1) + iL[6]); + label_41: { + label_42: { + iL[5] = ((iL[6] - iL[7]) & 7); + if (iL[5] != 0) { + break label_42; + } + iL[4] = iL[7]; + break label_41; + } + iL[4] = iL[7]; + label_43: while (true) { + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF))); + iL[0] = (iL[0] + 1); + iL[4] = (iL[4] + 1); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_43; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[8], 7) != 0) { + break label_40; + } + label_44: while (true) { + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 1, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 1) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 2, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 2) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 3, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 3) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 4) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 5, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 5) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 6, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 6) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 7, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 7) & 0xFF))); + iL[0] = (iL[0] + 8); + iL[4] = (iL[4] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[6], iL[4]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_44; + } + break; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[0]); + } + iL[0] = (iL[2] + 32); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 24, (long) memory.readLong((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + memory.writeI32((int) (iL[3] + 40) < 0 ? (iL[3] + 40) : (iL[3] + 40) + 0, (int) memory.readInt((int) (iL[0] + 16) < 0 ? (iL[0] + 16) : (iL[0] + 16) + 0)); + memory.writeLong((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0, (long) memory.readLong((int) (iL[0] + 8) < 0 ? (iL[0] + 8) : (iL[0] + 8) + 0)); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 200, (int) (iL[3] + 44)); + break label_35; + } + long[] callArgs_50 = new long[2]; + callArgs_50[1] = ((long) (iL[2] + 8)); + callArgs_50[0] = ((long) (iL[1] + 196)); + instance.getMachine().call(1218, callArgs_50); + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 20); + } + label_45: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[7]) != 0) { + break label_45; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 24, (int) iL[7]); + long[] callArgs_51 = new long[1]; + callArgs_51[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_51); + } + label_46: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[2] < 0 ? iL[2] : iL[2] + 19), -1) != 0) { + break label_46; + } + long[] callArgs_52 = new long[1]; + callArgs_52[0] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 8)); + instance.getMachine().call(1777, callArgs_52); + } + iL[6] = 0; + } + iL[0] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_6; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 156, (int) iL[0]); + long[] callArgs_53 = new long[1]; + callArgs_53[0] = ((long) iL[0]); + instance.getMachine().call(1777, callArgs_53); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[2] < 0 ? iL[2] : iL[2] + 179), -1) != 0) { + break label_5; + } + long[] callArgs_54 = new long[1]; + callArgs_54[0] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 168)); + instance.getMachine().call(1777, callArgs_54); + } + instance.global(0).setValue(((long) (iL[2] + 208))); + return iL[6]; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1212(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1212(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1213(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = 1; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + local3 = ((int) callResult_0[0]); + switch((local3 + -13)) { + case 0: + { + break label_12; + } + case 1: + { + break label_1; + } + case 2: + { + break label_1; + } + case 3: + { + break label_1; + } + case 4: + { + break label_1; + } + case 5: + { + break label_11; + } + case 6: + { + break label_1; + } + case 7: + { + break label_10; + } + case 8: + { + break label_9; + } + case 9: + { + break label_1; + } + case 10: + { + break label_1; + } + case 11: + { + break label_1; + } + case 12: + { + break label_6; + } + case 13: + { + break label_5; + } + case 14: + { + break label_1; + } + case 15: + { + break label_1; + } + case 16: + { + break label_1; + } + case 17: + { + break label_1; + } + case 18: + { + break label_4; + } + case 19: + { + break label_1; + } + case 20: + { + break label_1; + } + case 21: + { + break label_1; + } + case 22: + { + break label_1; + } + case 23: + { + break label_1; + } + case 24: + { + break label_1; + } + case 25: + { + break label_1; + } + case 26: + { + break label_1; + } + case 27: + { + break label_1; + } + case 28: + { + break label_1; + } + case 29: + { + break label_1; + } + case 30: + { + break label_1; + } + case 31: + { + break label_1; + } + case 32: + { + break label_1; + } + case 33: + { + break label_3; + } + case 34: + { + break label_1; + } + case 35: + { + break label_2; + } + case 36: + { + break label_1; + } + case 37: + { + break label_7; + } + default: + { + break label_8; + } + } + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1219, callArgs_1); + return ((int) callResult_1[0]); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1220, callArgs_2); + return ((int) callResult_2[0]); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1221, callArgs_3); + return ((int) callResult_3[0]); + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg1); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1222, callArgs_4); + return ((int) callResult_4[0]); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(138, local3) != 0) { + break label_1; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1223, callArgs_5); + return ((int) callResult_5[0]); + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) arg1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1224, callArgs_6); + return ((int) callResult_6[0]); + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1225, callArgs_7); + return ((int) callResult_7[0]); + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1226, callArgs_8); + return ((int) callResult_8[0]); + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) arg1); + callArgs_9[0] = ((long) arg0); + long[] callResult_9 = instance.getMachine().call(1227, callArgs_9); + return ((int) callResult_9[0]); + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) arg1); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1228, callArgs_10); + return ((int) callResult_10[0]); + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) arg1); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1229, callArgs_11); + local2 = ((int) callResult_11[0]); + } + return local2; + } + + public static long[] call_1213(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1213(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1214(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)) != 0) { + break label_1; + } + local3 = (arg1 + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg1 + 56) < 0 ? (arg1 + 56) : (arg1 + 56) + 0), memory.readInt((int) local3 < 0 ? local3 : local3 + 0)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg1 + 44) < 0 ? (arg1 + 44) : (arg1 + 44) + 0), memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 40)) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg1 + 4)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(132, callArgs_0); + arg0 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + local2 = 1; + local4 = (arg1 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((arg0 + 40), local4) != 0) { + break label_1; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0)); + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40)); + callArgs_1[0] = ((long) local4); + instance.getMachine().call(344, callArgs_1); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0)); + callArgs_2[1] = ((long) memory.readInt((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0)); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(344, callArgs_2); + memory.writeF32((int) (arg1 + 80) < 0 ? (arg1 + 80) : (arg1 + 80) + 0, (float) memory.readFloat((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0)); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) memory.readInt((int) (arg0 + 72) < 0 ? (arg0 + 72) : (arg0 + 72) + 0)); + callArgs_3[0] = ((long) (arg1 + 64)); + instance.getMachine().call(1304, callArgs_3); + memory.writeF32((int) (arg1 + 100) < 0 ? (arg1 + 100) : (arg1 + 100) + 0, (float) memory.readFloat((int) (arg0 + 100) < 0 ? (arg0 + 100) : (arg0 + 100) + 0)); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) memory.readInt((int) (arg0 + 92) < 0 ? (arg0 + 92) : (arg0 + 92) + 0)); + callArgs_4[0] = ((long) (arg1 + 84)); + instance.getMachine().call(1304, callArgs_4); + } + return local2; + } + + public static long[] call_1214(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1214(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1215(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + if (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF) != 0) { + break label_1; + } + local3 = (arg2 + 40); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(134, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, ((int) callResult_0[0])) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 40); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local4 = ((int) callResult_1[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 47928); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 108); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + arg0 = ((int) callResult_2[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) 0); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 35, (byte) (0)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 40, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48148); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 104, (byte) (0)); + memory.writeLong((int) (arg0 + 12) < 0 ? (arg0 + 12) : (arg0 + 12) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 17) < 0 ? (arg0 + 17) : (arg0 + 17) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0, (long) 0L); + memory.writeLong((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0, (long) 0L); + local5 = (arg0 + 64); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + memory.writeLong((int) (arg0 + 72) < 0 ? (arg0 + 72) : (arg0 + 72) + 0, (long) 0L); + local6 = (arg0 + 84); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeI32((int) (arg0 + 80) < 0 ? (arg0 + 80) : (arg0 + 80) + 0, (int) 1065353216); + memory.writeLong((int) (arg0 + 92) < 0 ? (arg0 + 92) : (arg0 + 92) + 0, (long) 0L); + memory.writeI32((int) (arg0 + 100) < 0 ? (arg0 + 100) : (arg0 + 100) + 0, (int) 1065353216); + label_2: { + local7 = (arg0 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local7) != 0) { + break label_2; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) memory.readInt((int) (arg2 + 44) < 0 ? (arg2 + 44) : (arg2 + 44) + 0)); + callArgs_3[1] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 40)); + callArgs_3[0] = ((long) local7); + instance.getMachine().call(344, callArgs_3); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) (arg2 + 56) < 0 ? (arg2 + 56) : (arg2 + 56) + 0)); + callArgs_4[1] = ((long) memory.readInt((int) (arg2 + 52) < 0 ? (arg2 + 52) : (arg2 + 52) + 0)); + callArgs_4[0] = ((long) (arg0 + 52)); + instance.getMachine().call(344, callArgs_4); + memory.writeF32((int) arg0 < 0 ? arg0 : arg0 + 80, (float) memory.readFloat((int) (arg2 + 80) < 0 ? (arg2 + 80) : (arg2 + 80) + 0)); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 0); + callArgs_5[1] = ((long) memory.readInt((int) (arg2 + 72) < 0 ? (arg2 + 72) : (arg2 + 72) + 0)); + callArgs_5[0] = ((long) local5); + instance.getMachine().call(1304, callArgs_5); + memory.writeF32((int) arg0 < 0 ? arg0 : arg0 + 100, (float) memory.readFloat((int) (arg2 + 100) < 0 ? (arg2 + 100) : (arg2 + 100) + 0)); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 0); + callArgs_6[1] = ((long) memory.readInt((int) (arg2 + 92) < 0 ? (arg2 + 92) : (arg2 + 92) + 0)); + callArgs_6[0] = ((long) local6); + instance.getMachine().call(1304, callArgs_6); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) arg0); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local4); + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(143, callArgs_7); + } + return; + } + + public static long[] call_1215(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1215(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1216(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + long local7 = 0L; + int local8 = 0; + local4 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local4)); + local5 = 0; + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF)) != 0) { + break label_2; + } + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (arg2 + 4)); + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(132, callArgs_0); + arg1 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_3; + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) arg3); + callArgs_1[3] = ((long) 7082); + callArgs_1[2] = ((long) (arg1 + 52)); + callArgs_1[1] = ((long) (arg2 + 52)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1308, callArgs_1); + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) arg3); + callArgs_2[3] = ((long) 6785); + callArgs_2[2] = ((long) (arg1 + 40)); + callArgs_2[1] = ((long) (arg2 + 40)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1308, callArgs_2); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0]))); + break label_2; + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (arg2 + 44) < 0 ? (arg2 + 44) : (arg2 + 44) + 0), memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 40)) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (arg2 + 56) < 0 ? (arg2 + 56) : (arg2 + 56) + 0), memory.readInt((int) (arg2 + 52) < 0 ? (arg2 + 52) : (arg2 + 52) + 0)) != 0) { + break label_2; + } + } + local5 = (arg2 + 28); + label_5: { + label_6: { + if (memory.readInt((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0) != 0) { + break label_6; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) 1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local4); + callArgs_3[1] = ((long) 5153); + callArgs_3[0] = ((long) (local4 + 24)); + instance.getMachine().call(39, callArgs_3); + label_7: { + label_8: { + arg2 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 8)) != 0) { + break label_8; + } + arg1 = memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0); + memory.writeI32((int) ((local4 + 40) + 16) < 0 ? ((local4 + 40) + 16) : ((local4 + 40) + 16) + 0, (int) arg1); + local6 = memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + memory.writeLong((int) ((local4 + 40) + 8) < 0 ? ((local4 + 40) + 8) : ((local4 + 40) + 8) + 0, (long) local6); + local7 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0); + local8 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 28); + local5 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 35); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 1); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) local7); + memory.writeLong((int) (arg2 + 12) < 0 ? (arg2 + 12) : (arg2 + 12) + 0, (long) local6); + memory.writeI32((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0, (int) arg1); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local7); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, 0); + local5 = (arg1 != 0 ? arg0 : (local5 & 255)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 2147483632) != 0) { + break label_1; + } + arg1 = (arg1 != 0 ? local8 : (local4 + 24)); + label_9: { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 10) != 0) { + break label_10; + } + arg0 = (arg2 + 24); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 35, (byte) (local5)); + break label_9; + } + local8 = ((local5 | 15) + 1); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local8); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg0 = ((int) callResult_4[0]); + memory.writeI32((int) (arg2 + 32) < 0 ? (arg2 + 32) : (arg2 + 32) + 0, (int) (local8 | -2147483648)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 24, (int) arg0); + memory.writeI32((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (int) local5); + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local5); + callArgs_5[1] = ((long) arg1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1891, callArgs_5); + memory.writeByte((int) (((int) callResult_5[0]) + local5) < 0 ? (((int) callResult_5[0]) + local5) : (((int) callResult_5[0]) + local5) + 0, (byte) (0)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 4, (int) (arg2 + 36)); + break label_7; + } + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) (local4 + 24)); + callArgs_6[2] = ((long) arg0); + callArgs_6[1] = ((long) (local4 + 36)); + callArgs_6[0] = ((long) arg3); + instance.getMachine().call(1309, callArgs_6); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 35), -1) != 0) { + break label_5; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 24)); + instance.getMachine().call(1777, callArgs_7); + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) 1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg2 < 0 ? arg2 : arg2 + 39), 0) != 0 ? memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 28) : local5)); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) (local4 + 16)); + callArgs_8[1] = ((long) 10667); + callArgs_8[0] = ((long) (local4 + 24)); + instance.getMachine().call(39, callArgs_8); + label_11: { + label_12: { + arg2 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 8)) != 0) { + break label_12; + } + arg1 = memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0); + memory.writeI32((int) ((local4 + 40) + 16) < 0 ? ((local4 + 40) + 16) : ((local4 + 40) + 16) + 0, (int) arg1); + local6 = memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + memory.writeLong((int) ((local4 + 40) + 8) < 0 ? ((local4 + 40) + 8) : ((local4 + 40) + 8) + 0, (long) local6); + local7 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0); + local8 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 28); + local5 = (int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 35); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) 1); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 4, (long) local7); + memory.writeLong((int) (arg2 + 12) < 0 ? (arg2 + 12) : (arg2 + 12) + 0, (long) local6); + memory.writeI32((int) (arg2 + 20) < 0 ? (arg2 + 20) : (arg2 + 20) + 0, (int) arg1); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 40, (long) local7); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, 0); + local5 = (arg1 != 0 ? arg0 : (local5 & 255)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 2147483632) != 0) { + break label_1; + } + arg1 = (arg1 != 0 ? local8 : (local4 + 24)); + label_13: { + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 10) != 0) { + break label_14; + } + arg0 = (arg2 + 24); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 35, (byte) (local5)); + break label_13; + } + local8 = ((local5 | 15) + 1); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local8); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + arg0 = ((int) callResult_9[0]); + memory.writeI32((int) (arg2 + 32) < 0 ? (arg2 + 32) : (arg2 + 32) + 0, (int) (local8 | -2147483648)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 24, (int) arg0); + memory.writeI32((int) (arg2 + 28) < 0 ? (arg2 + 28) : (arg2 + 28) + 0, (int) local5); + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) local5); + callArgs_10[1] = ((long) arg1); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1891, callArgs_10); + memory.writeByte((int) (((int) callResult_10[0]) + local5) < 0 ? (((int) callResult_10[0]) + local5) : (((int) callResult_10[0]) + local5) + 0, (byte) (0)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 4, (int) (arg2 + 36)); + break label_11; + } + long[] callArgs_11 = new long[4]; + callArgs_11[3] = ((long) (local4 + 24)); + callArgs_11[2] = ((long) arg0); + callArgs_11[1] = ((long) (local4 + 36)); + callArgs_11[0] = ((long) arg3); + instance.getMachine().call(1309, callArgs_11); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 35), -1) != 0) { + break label_5; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 24)); + instance.getMachine().call(1777, callArgs_12); + } + local5 = 1; + } + instance.global(0).setValue(((long) (local4 + 64))); + return local5; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1216(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1216(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1217(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_2; + } + local1 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local2 = ((arg0 + (local1 * 40)) + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local1 ^ 1))); + } + return; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1217(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1217(arg0, memory, instance); + return null; + } + + public static void func_1218(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2), 44); + local4 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 97612894) != 0) { + break label_4; + } + local5 = 0; + label_5: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 44); + local6 = (local2 << 1); + local7 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 48806446) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local4) != 0 ? local6 : local4) : 97612893); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 97612894) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local7 * 44)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local5 = ((int) callResult_0[0]); + } + local2 = (local5 + (local3 * 44)); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), 0) != 0) { + break label_7; + } + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_6; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1647, callArgs_1); + } + local8 = (local5 + (local3 * 44)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 12, (long) 0L); + local9 = (local8 + 20); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) 0); + label_8: { + local10 = memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local10) != 0) { + break label_8; + } + local6 = (local10 - local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local6, -1) != 0) { + break label_4; + } + local11 = (local8 + 16); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local4); + memory.writeI32((int) (local8 + 12) < 0 ? (local8 + 12) : (local8 + 12) + 0, (int) local4); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) (local4 + local6)); + local9 = ((local3 ^ -1) + local10); + label_9: { + local6 = (local6 & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_9; + } + label_10: while (true) { + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF))); + local4 = (local4 + 1); + local3 = (local3 + 1); + local6 = (local6 + -1); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, 7) != 0) { + break label_11; + } + label_12: while (true) { + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 1, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 1) & 0xFF))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 2, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 2) & 0xFF))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 3, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 3) & 0xFF))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 4, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 4) & 0xFF))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 5, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 5) & 0xFF))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 6, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 6) & 0xFF))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 7, (byte) (((int) memory.read((int) local3 < 0 ? local3 : local3 + 7) & 0xFF))); + local4 = (local4 + 8); + local3 = (local3 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local10, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break; + } + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local4); + } + local7 = (local5 + (local7 * 44)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 24, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 24)); + memory.writeI32((int) (local8 + 40) < 0 ? (local8 + 40) : (local8 + 40) + 0, (int) memory.readInt((int) (arg1 + 40) < 0 ? (arg1 + 40) : (arg1 + 40) + 0)); + memory.writeLong((int) (local8 + 32) < 0 ? (local8 + 32) : (local8 + 32) + 0, (long) memory.readLong((int) (arg1 + 32) < 0 ? (arg1 + 32) : (arg1 + 32) + 0)); + local9 = (local2 + 44); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local4) != 0) { + break label_2; + } + label_13: while (true) { + local6 = (local2 + -44); + local3 = (local4 + -44); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + local10 = (local3 + 8); + memory.writeI32((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (int) memory.readInt((int) local10 < 0 ? local10 : local10 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) 0); + local10 = (local2 + -32); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 0, (long) 0L); + arg1 = (local2 + -24); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + local8 = (local4 + -32); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 0, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + local10 = (local4 + -24); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local10 < 0 ? local10 : local10 + 0)); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 0, (int) 0); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + local2 = (local2 + -20); + local4 = (local4 + -20); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) memory.readInt((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + local4 = local3; + local2 = local6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local9); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, local3) != 0) { + break label_1; + } + local3 = (local3 + -44); + label_14: while (true) { + label_15: { + local2 = memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_15; + } + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) local2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local3 + 11) < 0 ? (local3 + 11) : (local3 + 11) + 0), -1) != 0) { + break label_16; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_4); + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3); + local3 = (local3 + -44); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + } + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_17; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_7); + } + return; + } + + public static long[] call_1218(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1218(arg0, arg1, memory, instance); + return null; + } + + public static int func_1219(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + label_2: { + local4 = (arg0 + 16); + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 88)); + instance.getMachine().call(557, callArgs_1); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 88) + 8) < 0 ? ((local2 + 88) + 8) : ((local2 + 88) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 88) + 16) < 0 ? ((local2 + 88) + 16) : ((local2 + 88) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 88) + 24) < 0 ? ((local2 + 88) + 24) : ((local2 + 88) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 88) + 32) < 0 ? ((local2 + 88) + 32) : ((local2 + 88) + 32) + 0)); + label_3: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + local3 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + } + label_4: { + label_5: { + label_6: { + label_7: { + local3 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_7; + } + local4 = ((local2 + 88) + 8); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + local5 = ((local2 + 88) + 16); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 88, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + local3 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 13); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1160, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_1; + } + memory.writeI32((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) 0L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 72)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1165, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 112); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local3 = ((int) callResult_4[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) 8L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 49816); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + local4 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 83) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + local4 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 76) : local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 2147483632) != 0) { + break label_6; + } + local6 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 72) : (local2 + 72)); + label_8: { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 10) != 0) { + break label_9; + } + local5 = (local3 + 40); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 51, (byte) (local4)); + break label_8; + } + local7 = ((local4 | 15) + 1); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local7); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + local5 = ((int) callResult_5[0]); + memory.writeI32((int) (local3 + 48) < 0 ? (local3 + 48) : (local3 + 48) + 0, (int) (local7 | -2147483648)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) local5); + memory.writeI32((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (int) local4); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local4); + callArgs_6[1] = ((long) local6); + callArgs_6[0] = ((long) local5); + long[] callResult_6 = instance.getMachine().call(1891, callArgs_6); + memory.writeByte((int) (((int) callResult_6[0]) + local4) < 0 ? (((int) callResult_6[0]) + local4) : (((int) callResult_6[0]) + local4) + 0, (byte) (0)); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) (local3 + 52)); + long[] callResult_7 = instance.getMachine().call(154, callArgs_7); + local4 = ((int) callResult_7[0]); + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) 0L); + memory.writeLong((int) (local3 + 96) < 0 ? (local3 + 96) : (local3 + 96) + 0, (long) 0L); + local5 = (local3 + 88); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + label_10: { + label_11: { + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) 0); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1154, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_8[0])) != 0) { + break label_11; + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) 1); + callArgs_9[0] = ((long) arg0); + long[] callResult_9 = instance.getMachine().call(1154, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(31, ((int) callResult_9[0])) != 0) { + break label_11; + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) 30); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1160, callArgs_10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_10[0])) != 0) { + break label_5; + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 31); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1160, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + break label_5; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) local4); + callArgs_12[0] = ((long) arg0); + long[] callResult_12 = instance.getMachine().call(1166, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) != 0) { + break label_5; + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) 44); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(1160, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_13[0])) != 0) { + break label_5; + } + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) local5); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(1171, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])) != 0) { + break label_5; + } + break label_10; + } + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) (local2 + 88)); + callArgs_15[1] = ((long) 0); + callArgs_15[0] = ((long) (local2 + 32)); + long[] callResult_15 = instance.getMachine().call(155, callArgs_15); + local6 = ((int) callResult_15[0]); + label_12: { + label_13: { + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) 0); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1154, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(59, ((int) callResult_16[0])) != 0) { + break label_13; + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) 0); + callArgs_17[0] = ((long) arg0); + long[] callResult_17 = instance.getMachine().call(1154, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_17[0])) != 0) { + break label_12; + } + } + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) local4); + callArgs_18[0] = ((long) arg0); + long[] callResult_18 = instance.getMachine().call(1166, callArgs_18); + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) local6); + long[] callResult_19 = instance.getMachine().call(162, callArgs_19); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) local5); + callArgs_20[0] = ((long) arg0); + long[] callResult_20 = instance.getMachine().call(1171, callArgs_20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_20[0])) != 0) { + break label_5; + } + break label_10; + } + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) local6); + callArgs_21[0] = ((long) local4); + long[] callResult_21 = instance.getMachine().call(160, callArgs_21); + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) local6); + long[] callResult_22 = instance.getMachine().call(162, callArgs_22); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) local5); + callArgs_23[0] = ((long) arg0); + long[] callResult_23 = instance.getMachine().call(1172, callArgs_23); + if (((int) callResult_23[0]) != 0) { + break label_10; + } + label_14: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 9) & 0xFF) != 0) { + break label_14; + } + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) ((local2 + 88) + 16) < 0 ? ((local2 + 88) + 16) : ((local2 + 88) + 16) + 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) ((local2 + 88) + 8) < 0 ? ((local2 + 88) + 8) : ((local2 + 88) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + long[] callArgs_24 = new long[4]; + callArgs_24[3] = ((long) 0); + callArgs_24[2] = ((long) 18427); + callArgs_24[1] = ((long) (local2 + 8)); + callArgs_24[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_24); + break label_5; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) 1); + } + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) (local3 + 100)); + callArgs_25[0] = ((long) arg0); + long[] callResult_25 = instance.getMachine().call(1183, callArgs_25); + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) 44); + callArgs_26[0] = ((long) arg0); + long[] callResult_26 = instance.getMachine().call(1160, callArgs_26); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_26[0])) != 0) { + break label_5; + } + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) local3); + callArgs_27[0] = ((long) arg1); + instance.getMachine().call(136, callArgs_27); + local3 = 0; + break label_4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + int ciTableIdx_30 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_30 = instance.table(0).requiredRef(ciTableIdx_30); + com.dylibso.chicory.runtime.Instance ciRefInstance_30 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_30), instance); + if (!ciRefInstance_30.type(ciRefInstance_30.functionType(ciFuncId_30)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) local3); + ciRefInstance_30.getMachine().call(ciFuncId_30, callArgs_30); + local3 = 1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 83), -1) != 0) { + break label_1; + } + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + instance.getMachine().call(1777, callArgs_31); + } + instance.global(0).setValue(((long) (local2 + 128))); + return local3; + } + + public static long[] call_1219(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1219(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1220(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + local2 = (((int) instance.global(0).getValue()) - 192); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + label_2: { + local4 = (arg0 + 16); + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 152)); + instance.getMachine().call(557, callArgs_1); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 152)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 152) + 8) < 0 ? ((local2 + 152) + 8) : ((local2 + 152) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 152) + 16) < 0 ? ((local2 + 152) + 16) : ((local2 + 152) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 152) + 24) < 0 ? ((local2 + 152) + 24) : ((local2 + 152) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 152) + 32) < 0 ? ((local2 + 152) + 32) : ((local2 + 152) + 32) + 0)); + label_3: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + local3 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + } + label_4: { + label_5: { + label_6: { + label_7: { + local3 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_7; + } + memory.writeLong((int) ((local2 + 128) + 8) < 0 ? ((local2 + 128) + 8) : ((local2 + 128) + 8) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeI32((int) ((local2 + 128) + 16) < 0 ? ((local2 + 128) + 16) : ((local2 + 128) + 16) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 128, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + local3 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 18); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1160, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_1; + } + memory.writeI32((int) ((local2 + 112) + 8) < 0 ? ((local2 + 112) + 8) : ((local2 + 112) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 112, (long) 0L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 112)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1165, callArgs_3); + local6 = ((int) callResult_3[0]); + label_8: { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 123), 0) != 0) { + break label_9; + } + memory.writeI32((int) ((local2 + 96) + 8) < 0 ? ((local2 + 96) + 8) : ((local2 + 96) + 8) + 0, (int) memory.readInt((int) ((local2 + 112) + 8) < 0 ? ((local2 + 112) + 8) : ((local2 + 112) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 96, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 112)); + break label_8; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 116)); + callArgs_4[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 112)); + callArgs_4[0] = ((long) (local2 + 96)); + instance.getMachine().call(1647, callArgs_4); + } + label_10: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 9) & 0xFF) != 0) { + break label_10; + } + label_11: { + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 107), -1) != 0) { + break label_12; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 100, (int) 0); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 96); + break label_11; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 107, (byte) (0)); + local3 = (local2 + 96); + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (0)); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 120); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + local3 = ((int) callResult_5[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 32, (long) 6L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 49940); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 128)); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) memory.readLong((int) (local2 + 136) < 0 ? (local2 + 136) : (local2 + 136) + 0)); + memory.writeI32((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (int) memory.readInt((int) (local2 + 144) < 0 ? (local2 + 144) : (local2 + 144) + 0)); + local5 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 107) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local5), 0); + local5 = (local7 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 100) : local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 2147483632) != 0) { + break label_6; + } + local8 = (local7 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 96) : (local2 + 96)); + label_13: { + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 10) != 0) { + break label_14; + } + local7 = (local3 + 40); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 51, (byte) (local5)); + break label_13; + } + local9 = ((local5 | 15) + 1); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local9); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + local7 = ((int) callResult_6[0]); + memory.writeI32((int) (local3 + 48) < 0 ? (local3 + 48) : (local3 + 48) + 0, (int) (local9 | -2147483648)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 40, (int) local7); + memory.writeI32((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (int) local5); + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local5); + callArgs_7[1] = ((long) local8); + callArgs_7[0] = ((long) local7); + long[] callResult_7 = instance.getMachine().call(1891, callArgs_7); + memory.writeByte((int) (((int) callResult_7[0]) + local5) < 0 ? (((int) callResult_7[0]) + local5) : (((int) callResult_7[0]) + local5) + 0, (byte) (0)); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) (local3 + 52)); + long[] callResult_8 = instance.getMachine().call(154, callArgs_8); + local5 = ((int) callResult_8[0]); + memory.writeLong((int) (local3 + 112) < 0 ? (local3 + 112) : (local3 + 112) + 0, (long) 0L); + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) 0L); + local7 = (local3 + 96); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 10) & 0xFF)) != 0) { + break label_15; + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) 0); + callArgs_9[0] = ((long) arg0); + long[] callResult_9 = instance.getMachine().call(1154, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(14, ((int) callResult_9[0])) != 0) { + break label_15; + } + local8 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local9 = (local4 + (local8 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local9 < 0 ? local9 : local9 + 36) & 0xFF)) != 0) { + break label_7; + } + memory.writeByte((int) (local9 + 36) < 0 ? (local9 + 36) : (local9 + 36) + 0, (byte) (0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) 2); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local8 ^ 1))); + } + label_16: { + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 9) & 0xFF)) != 0) { + break label_17; + } + label_18: { + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) 0); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1154, callArgs_10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_10[0])) != 0) { + break label_18; + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 1); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1154, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(48, ((int) callResult_11[0])) != 0) { + break label_18; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) 30); + callArgs_12[0] = ((long) arg0); + long[] callResult_12 = instance.getMachine().call(1160, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) != 0) { + break label_5; + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) 48); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(1160, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_13[0])) != 0) { + break label_5; + } + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) local5); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(1166, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])) != 0) { + break label_5; + } + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) 44); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1160, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_15[0])) != 0) { + break label_16; + } + break label_5; + } + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) (local2 + 128)); + callArgs_16[1] = ((long) 0); + callArgs_16[0] = ((long) (local2 + 56)); + long[] callResult_16 = instance.getMachine().call(155, callArgs_16); + local8 = ((int) callResult_16[0]); + label_19: { + label_20: { + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) 0); + callArgs_17[0] = ((long) arg0); + long[] callResult_17 = instance.getMachine().call(1154, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(59, ((int) callResult_17[0])) != 0) { + break label_20; + } + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) 0); + callArgs_18[0] = ((long) arg0); + long[] callResult_18 = instance.getMachine().call(1154, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_18[0])) != 0) { + break label_19; + } + } + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) local5); + callArgs_19[0] = ((long) arg0); + long[] callResult_19 = instance.getMachine().call(1166, callArgs_19); + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) local8); + long[] callResult_20 = instance.getMachine().call(162, callArgs_20); + break label_16; + } + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) local8); + callArgs_21[0] = ((long) local5); + long[] callResult_21 = instance.getMachine().call(160, callArgs_21); + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) local8); + long[] callResult_22 = instance.getMachine().call(162, callArgs_22); + break label_16; + } + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_21; + } + local8 = (int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 123); + _snap_0 = local8; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local8, 0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 52, (int) (local8 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 116) : (_snap_0 & 255))); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) (local8 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 112) : (local2 + 112))); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 48)); + long[] callArgs_23 = new long[3]; + callArgs_23[2] = ((long) (local2 + 128)); + callArgs_23[1] = ((long) local2); + callArgs_23[0] = ((long) (local2 + 152)); + long[] callResult_23 = instance.getMachine().call(156, callArgs_23); + local8 = ((int) callResult_23[0]); + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) local8); + callArgs_24[0] = ((long) local5); + long[] callResult_24 = instance.getMachine().call(158, callArgs_24); + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) local8); + long[] callResult_25 = instance.getMachine().call(162, callArgs_25); + break label_16; + } + long[] callArgs_26 = new long[3]; + callArgs_26[2] = ((long) (local2 + 128)); + callArgs_26[1] = ((long) 0); + callArgs_26[0] = ((long) (local2 + 8)); + long[] callResult_26 = instance.getMachine().call(155, callArgs_26); + local8 = ((int) callResult_26[0]); + label_22: { + label_23: { + label_24: { + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) 0); + callArgs_27[0] = ((long) arg0); + long[] callResult_27 = instance.getMachine().call(1154, callArgs_27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(59, ((int) callResult_27[0])) != 0) { + break label_24; + } + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) 0); + callArgs_28[0] = ((long) arg0); + long[] callResult_28 = instance.getMachine().call(1154, callArgs_28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_28[0])) != 0) { + break label_23; + } + } + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) local5); + callArgs_29[0] = ((long) arg0); + long[] callResult_29 = instance.getMachine().call(1166, callArgs_29); + break label_22; + } + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) local8); + callArgs_30[0] = ((long) local5); + long[] callResult_30 = instance.getMachine().call(160, callArgs_30); + } + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) local8); + long[] callResult_31 = instance.getMachine().call(162, callArgs_31); + } + label_25: { + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 9) & 0xFF)) != 0) { + break label_26; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(2, memory.readInt((int) local3 < 0 ? local3 : local3 + 36)) != 0) { + break label_25; + } + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) local7); + callArgs_32[0] = ((long) arg0); + long[] callResult_32 = instance.getMachine().call(1172, callArgs_32); + if (((int) callResult_32[0]) != 0) { + break label_25; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) 1); + break label_25; + } + long[] callArgs_33 = new long[2]; + callArgs_33[1] = ((long) local7); + callArgs_33[0] = ((long) arg0); + long[] callResult_33 = instance.getMachine().call(1171, callArgs_33); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_33[0])) != 0) { + break label_5; + } + } + label_27: { + label_28: { + long[] callArgs_34 = new long[2]; + callArgs_34[1] = ((long) 0); + callArgs_34[0] = ((long) arg0); + long[] callResult_34 = instance.getMachine().call(1154, callArgs_34); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(137, ((int) callResult_34[0])) != 0) { + break label_28; + } + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local4 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_7; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + label_29: { + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-17, (int) local10) != 0) { + break label_29; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 10) & 0xFF)) != 0) { + break label_28; + } + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 88, (long) local10); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 160, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 152, (long) 0L); + label_30: { + long[] callArgs_35 = new long[2]; + callArgs_35[1] = ((long) (local2 + 152)); + callArgs_35[0] = ((long) arg0); + long[] callResult_35 = instance.getMachine().call(1186, callArgs_35); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_35[0])) != 0) { + break label_30; + } + local5 = (local3 + 108); + label_31: while (true) { + label_32: { + label_33: { + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 112); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, memory.readInt((int) local3 < 0 ? local3 : local3 + 116)) != 0) { + break label_33; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 152)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 160)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 112, (int) (local4 + 12)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 152, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 156, (long) 0L); + break label_32; + } + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) (local2 + 152)); + callArgs_36[0] = ((long) local5); + instance.getMachine().call(1188, callArgs_36); + } + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) (local2 + 152)); + callArgs_37[0] = ((long) arg0); + long[] callResult_37 = instance.getMachine().call(1186, callArgs_37); + if (((int) callResult_37[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_31; + } + break; + } + } + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_27; + } + label_34: while (true) { + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + int ciTableIdx_38 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_38 = instance.table(0).requiredRef(ciTableIdx_38); + com.dylibso.chicory.runtime.Instance ciRefInstance_38 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_38), instance); + if (!ciRefInstance_38.type(ciRefInstance_38.functionType(ciFuncId_38)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_38 = new long[1]; + callArgs_38[0] = ((long) local4); + ciRefInstance_38.getMachine().call(ciFuncId_38, callArgs_38); + local4 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_34; + } + break label_27; + } + } + memory.writeLong((int) local3 < 0 ? local3 : local3 + 88, (long) -16L); + label_35: { + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) 0); + callArgs_39[0] = ((long) arg0); + long[] callResult_39 = instance.getMachine().call(1154, callArgs_39); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(138, ((int) callResult_39[0])) != 0) { + break label_35; + } + long[] callArgs_40 = new long[2]; + callArgs_40[1] = ((long) 138); + callArgs_40[0] = ((long) arg0); + long[] callResult_40 = instance.getMachine().call(1160, callArgs_40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_40[0])) != 0) { + break label_5; + } + } + long[] callArgs_41 = new long[2]; + callArgs_41[1] = ((long) (local3 + 108)); + callArgs_41[0] = ((long) arg0); + long[] callResult_41 = instance.getMachine().call(1190, callArgs_41); + } + long[] callArgs_42 = new long[2]; + callArgs_42[1] = ((long) 44); + callArgs_42[0] = ((long) arg0); + long[] callResult_42 = instance.getMachine().call(1160, callArgs_42); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_42[0])) != 0) { + break label_5; + } + long[] callArgs_43 = new long[2]; + callArgs_43[1] = ((long) local3); + callArgs_43[0] = ((long) arg1); + instance.getMachine().call(139, callArgs_43); + local3 = 0; + break label_4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + int ciTableIdx_46 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_46 = instance.table(0).requiredRef(ciTableIdx_46); + com.dylibso.chicory.runtime.Instance ciRefInstance_46 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_46), instance); + if (!ciRefInstance_46.type(ciRefInstance_46.functionType(ciFuncId_46)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_46 = new long[1]; + callArgs_46[0] = ((long) local3); + ciRefInstance_46.getMachine().call(ciFuncId_46, callArgs_46); + local3 = 1; + } + label_36: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 107), -1) != 0) { + break label_36; + } + long[] callArgs_47 = new long[1]; + callArgs_47[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 96)); + instance.getMachine().call(1777, callArgs_47); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 123), -1) != 0) { + break label_1; + } + long[] callArgs_48 = new long[1]; + callArgs_48[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 112)); + instance.getMachine().call(1777, callArgs_48); + } + instance.global(0).setValue(((long) (local2 + 192))); + return local3; + } + + public static long[] call_1220(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1220(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1221(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 0) & 0xFF) != 0) { + break label_6; + } + arg1 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local3 = ((arg0 + 16) + (arg1 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_5; + } + local4 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((arg1 ^ 1))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 36, (byte) (0)); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 18411); + callArgs_0[1] = ((long) (local2 + 8)); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_0); + break label_1; + } + local4 = 1; + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 30); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1160, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + local4 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 20); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1160, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_1; + } + label_7: { + local4 = (arg0 + 16); + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_7; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_3[0] = ((long) (local2 + 120)); + instance.getMachine().call(557, callArgs_3); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 120)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 120) + 8) < 0 ? ((local2 + 120) + 8) : ((local2 + 120) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 120) + 16) < 0 ? ((local2 + 120) + 16) : ((local2 + 120) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 120) + 24) < 0 ? ((local2 + 120) + 24) : ((local2 + 120) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 120) + 32) < 0 ? ((local2 + 120) + 32) : ((local2 + 120) + 32) + 0)); + label_8: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_8; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_7; + } + local3 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + } + local3 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_5; + } + memory.writeLong((int) ((local2 + 96) + 8) < 0 ? ((local2 + 96) + 8) : ((local2 + 96) + 8) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeI32((int) ((local2 + 96) + 16) < 0 ? ((local2 + 96) + 16) : ((local2 + 96) + 16) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 96, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) ((local2 + 80) + 8) < 0 ? ((local2 + 80) + 8) : ((local2 + 80) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 80, (long) 0L); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 80)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1165, callArgs_4); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 72, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 64, (long) 0L); + local4 = 1; + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 4); + callArgs_5[1] = ((long) (local2 + 64)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1230, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_2; + } + label_9: { + label_10: { + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 0); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_6[0])) != 0) { + break label_10; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1154, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(26, ((int) callResult_7[0])) != 0) { + break label_10; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) arg1); + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(1231, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) 148); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + local3 = ((int) callResult_9[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) 4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 50064); + memory.writeLong((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0, (long) 0L); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) 0L); + local4 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 91) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + local4 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 2147483632) != 0) { + break label_4; + } + local6 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 80) : (local2 + 80)); + label_11: { + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 10) != 0) { + break label_12; + } + local5 = (local3 + 32); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 43, (byte) (local4)); + break label_11; + } + local7 = ((local4 | 15) + 1); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local7); + long[] callResult_10 = instance.getMachine().call(1776, callArgs_10); + local5 = ((int) callResult_10[0]); + memory.writeI32((int) (local3 + 40) < 0 ? (local3 + 40) : (local3 + 40) + 0, (int) (local7 | -2147483648)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local5); + memory.writeI32((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (int) local4); + } + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) local4); + callArgs_11[1] = ((long) local6); + callArgs_11[0] = ((long) local5); + long[] callResult_11 = instance.getMachine().call(1891, callArgs_11); + memory.writeByte((int) (((int) callResult_11[0]) + local4) < 0 ? (((int) callResult_11[0]) + local4) : (((int) callResult_11[0]) + local4) + 0, (byte) (0)); + local5 = (local3 + 44); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (0)); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) (local3 + 48)); + long[] callResult_12 = instance.getMachine().call(154, callArgs_12); + memory.writeLong((int) (local3 + 116) < 0 ? (local3 + 116) : (local3 + 116) + 0, (long) 0L); + memory.writeLong((int) (local3 + 108) < 0 ? (local3 + 108) : (local3 + 108) + 0, (long) 0L); + memory.writeLong((int) (local3 + 100) < 0 ? (local3 + 100) : (local3 + 100) + 0, (long) 0L); + memory.writeLong((int) (local3 + 92) < 0 ? (local3 + 92) : (local3 + 92) + 0, (long) 0L); + local6 = (local3 + 84); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeLong((int) (local3 + 128) < 0 ? (local3 + 128) : (local3 + 128) + 0, (long) 0L); + memory.writeI32((int) (local3 + 124) < 0 ? (local3 + 124) : (local3 + 124) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 136) < 0 ? (local3 + 136) : (local3 + 136) + 0, (long) 0L); + memory.writeI32((int) (local3 + 144) < 0 ? (local3 + 144) : (local3 + 144) + 0, (int) 1065353216); + local4 = 1; + label_13: { + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) 30); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(1160, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_13[0])) != 0) { + break label_13; + } + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) 26); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(1160, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])) != 0) { + break label_13; + } + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) 1); + callArgs_15[1] = ((long) (local3 + 4)); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1196, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_15[0])) != 0) { + break label_13; + } + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) 1); + callArgs_16[1] = ((long) (local3 + 16)); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1196, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_16[0])) != 0) { + break label_13; + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) 44); + callArgs_17[0] = ((long) arg0); + long[] callResult_17 = instance.getMachine().call(1160, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_17[0])) != 0) { + break label_13; + } + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) local5); + callArgs_18[0] = ((long) arg0); + long[] callResult_18 = instance.getMachine().call(1232, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_18[0])) != 0) { + break label_13; + } + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) local6); + callArgs_19[0] = ((long) arg0); + long[] callResult_19 = instance.getMachine().call(1233, callArgs_19); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_19[0])) != 0) { + break label_13; + } + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) 16363); + callArgs_20[0] = ((long) (local2 + 120)); + long[] callResult_20 = instance.getMachine().call(1167, callArgs_20); + local5 = ((int) callResult_20[0]); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) 13044); + callArgs_21[0] = ((long) (local5 + 12)); + long[] callResult_21 = instance.getMachine().call(1167, callArgs_21); + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) 7082); + callArgs_22[0] = ((long) (local5 + 24)); + long[] callResult_22 = instance.getMachine().call(1167, callArgs_22); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 44, (int) 3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) local5); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 40)); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) (local2 + 32)); + callArgs_23[0] = ((long) (local2 + 48)); + long[] callResult_23 = instance.getMachine().call(1168, callArgs_23); + local6 = ((int) callResult_23[0]); + long[] callArgs_24 = new long[3]; + callArgs_24[2] = ((long) 0); + callArgs_24[1] = ((long) local6); + callArgs_24[0] = ((long) arg0); + long[] callResult_24 = instance.getMachine().call(1164, callArgs_24); + local7 = ((int) callResult_24[0]); + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) local6); + long[] callResult_25 = instance.getMachine().call(1169, callArgs_25); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 35), -1) != 0) { + break label_14; + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 24)); + instance.getMachine().call(1777, callArgs_26); + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 23), -1) != 0) { + break label_15; + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 12)); + instance.getMachine().call(1777, callArgs_27); + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 11), -1) != 0) { + break label_16; + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + instance.getMachine().call(1777, callArgs_28); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7) != 0) { + break label_13; + } + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) arg0); + callArgs_29[0] = ((long) (local2 + 120)); + instance.getMachine().call(1153, callArgs_29); + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) 40); + long[] callResult_30 = instance.getMachine().call(1776, callArgs_30); + local4 = ((int) callResult_30[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 50208); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 120)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (local2 + 128) < 0 ? (local2 + 128) : (local2 + 128) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local2 + 136) < 0 ? (local2 + 136) : (local2 + 136) + 0)); + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) local4); + callArgs_31[0] = ((long) arg1); + instance.getMachine().call(145, callArgs_31); + break label_9; + } + int ciTableIdx_32 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_32 = instance.table(0).requiredRef(ciTableIdx_32); + com.dylibso.chicory.runtime.Instance ciRefInstance_32 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_32), instance); + if (!ciRefInstance_32.type(ciRefInstance_32.functionType(ciFuncId_32)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) local3); + ciRefInstance_32.getMachine().call(ciFuncId_32, callArgs_32); + break label_2; + } + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) 152); + long[] callResult_33 = instance.getMachine().call(1776, callArgs_33); + local3 = ((int) callResult_33[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 10); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 50328); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 96)); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) memory.readLong((int) (local2 + 104) < 0 ? (local2 + 104) : (local2 + 104) + 0)); + memory.writeI32((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (int) memory.readInt((int) (local2 + 112) < 0 ? (local2 + 112) : (local2 + 112) + 0)); + local4 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 91) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + local4 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 84) : local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 2147483632) != 0) { + break label_4; + } + local6 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 80) : (local2 + 80)); + label_17: { + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 10) != 0) { + break label_18; + } + local5 = (local3 + 36); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 47, (byte) (local4)); + break label_17; + } + local7 = ((local4 | 15) + 1); + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) local7); + long[] callResult_34 = instance.getMachine().call(1776, callArgs_34); + local5 = ((int) callResult_34[0]); + memory.writeI32((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (int) (local7 | -2147483648)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local5); + memory.writeI32((int) (local3 + 40) < 0 ? (local3 + 40) : (local3 + 40) + 0, (int) local4); + } + long[] callArgs_35 = new long[3]; + callArgs_35[2] = ((long) local4); + callArgs_35[1] = ((long) local6); + callArgs_35[0] = ((long) local5); + long[] callResult_35 = instance.getMachine().call(1891, callArgs_35); + memory.writeByte((int) (((int) callResult_35[0]) + local4) < 0 ? (((int) callResult_35[0]) + local4) : (((int) callResult_35[0]) + local4) + 0, (byte) (0)); + local5 = (local3 + 48); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (0)); + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) (local3 + 52)); + long[] callResult_36 = instance.getMachine().call(154, callArgs_36); + memory.writeLong((int) (local3 + 120) < 0 ? (local3 + 120) : (local3 + 120) + 0, (long) 0L); + memory.writeLong((int) (local3 + 112) < 0 ? (local3 + 112) : (local3 + 112) + 0, (long) 0L); + memory.writeLong((int) (local3 + 104) < 0 ? (local3 + 104) : (local3 + 104) + 0, (long) 0L); + memory.writeLong((int) (local3 + 96) < 0 ? (local3 + 96) : (local3 + 96) + 0, (long) 0L); + local6 = (local3 + 88); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeLong((int) (local3 + 132) < 0 ? (local3 + 132) : (local3 + 132) + 0, (long) 0L); + memory.writeI32((int) (local3 + 128) < 0 ? (local3 + 128) : (local3 + 128) + 0, (int) 1065353216); + memory.writeLong((int) (local3 + 140) < 0 ? (local3 + 140) : (local3 + 140) + 0, (long) 0L); + memory.writeI32((int) (local3 + 148) < 0 ? (local3 + 148) : (local3 + 148) + 0, (int) 1065353216); + local4 = 1; + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) local5); + callArgs_37[0] = ((long) arg0); + long[] callResult_37 = instance.getMachine().call(1232, callArgs_37); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_37[0])) != 0) { + break label_3; + } + long[] callArgs_38 = new long[2]; + callArgs_38[1] = ((long) local6); + callArgs_38[0] = ((long) arg0); + long[] callResult_38 = instance.getMachine().call(1233, callArgs_38); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_38[0])) != 0) { + break label_3; + } + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) local3); + callArgs_39[0] = ((long) arg1); + instance.getMachine().call(140, callArgs_39); + } + long[] callArgs_40 = new long[3]; + callArgs_40[2] = ((long) (((memory.readInt((int) (arg1 + 68) < 0 ? (arg1 + 68) : (arg1 + 68) + 0) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 64)) >> 2) + -1)); + callArgs_40[1] = ((long) (local2 + 64)); + callArgs_40[0] = ((long) arg1); + instance.getMachine().call(1234, callArgs_40); + long[] callArgs_41 = new long[2]; + callArgs_41[1] = ((long) 44); + callArgs_41[0] = ((long) arg0); + long[] callResult_41 = instance.getMachine().call(1160, callArgs_41); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_41[0])); + break label_2; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + int ciTableIdx_44 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_44 = instance.table(0).requiredRef(ciTableIdx_44); + com.dylibso.chicory.runtime.Instance ciRefInstance_44 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_44), instance); + if (!ciRefInstance_44.type(ciRefInstance_44.functionType(ciFuncId_44)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_44 = new long[1]; + callArgs_44[0] = ((long) local3); + ciRefInstance_44.getMachine().call(ciFuncId_44, callArgs_44); + } + label_19: { + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_19; + } + label_20: while (true) { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + int ciTableIdx_45 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_45 = instance.table(0).requiredRef(ciTableIdx_45); + com.dylibso.chicory.runtime.Instance ciRefInstance_45 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_45), instance); + if (!ciRefInstance_45.type(ciRefInstance_45.functionType(ciFuncId_45)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_45 = new long[1]; + callArgs_45[0] = ((long) arg0); + ciRefInstance_45.getMachine().call(ciFuncId_45, callArgs_45); + arg0 = local3; + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 91), -1) != 0) { + break label_1; + } + long[] callArgs_46 = new long[1]; + callArgs_46[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 80)); + instance.getMachine().call(1777, callArgs_46); + } + instance.global(0).setValue(((long) (local2 + 160))); + return local4; + } + + public static long[] call_1221(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1221(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1222(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_2; + } + label_3: { + local3 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 8)); + instance.getMachine().call(557, callArgs_1); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 8) + 24) < 0 ? ((local2 + 8) + 24) : ((local2 + 8) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 8) + 32) < 0 ? ((local2 + 8) + 32) : ((local2 + 8) + 32) + 0)); + label_4: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_4; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + local3 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 88); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 3); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 36, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 50448); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeI32((int) (local4 + 44) < 0 ? (local4 + 44) : (local4 + 44) + 0, (int) 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (local4 + 52)); + long[] callResult_3 = instance.getMachine().call(154, callArgs_3); + local3 = 1; + label_5: { + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 21); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1160, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_5; + } + local5 = (local4 + 36); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) local5); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1196, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_5; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local5); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1235, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_6[0])) != 0) { + break label_5; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 44); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1160, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_7[0])) != 0) { + break label_5; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local4); + callArgs_8[0] = ((long) arg1); + instance.getMachine().call(141, callArgs_8); + local3 = 0; + break label_2; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + instance.global(0).setValue(((long) (local2 + 48))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1222(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1222(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1223(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_3; + } + label_4: { + local4 = (arg0 + 16); + local5 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 80)); + instance.getMachine().call(557, callArgs_1); + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local3 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) * 40)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 80)); + memory.writeLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (long) memory.readLong((int) ((local2 + 80) + 8) < 0 ? ((local2 + 80) + 8) : ((local2 + 80) + 8) + 0)); + memory.writeLong((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (long) memory.readLong((int) ((local2 + 80) + 16) < 0 ? ((local2 + 80) + 16) : ((local2 + 80) + 16) + 0)); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) memory.readLong((int) ((local2 + 80) + 24) < 0 ? ((local2 + 80) + 24) : ((local2 + 80) + 24) + 0)); + memory.writeI32((int) (local3 + 32) < 0 ? (local3 + 32) : (local3 + 32) + 0, (int) memory.readInt((int) ((local2 + 80) + 32) < 0 ? ((local2 + 80) + 32) : ((local2 + 80) + 32) + 0)); + label_5: { + if (((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF) != 0) { + break label_5; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + local5 = (local5 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + } + local5 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeLong((int) ((local2 + 56) + 8) < 0 ? ((local2 + 56) + 8) : ((local2 + 56) + 8) + 0, (long) memory.readLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + memory.writeI32((int) ((local2 + 56) + 16) < 0 ? ((local2 + 56) + 16) : ((local2 + 56) + 16) + 0, (int) memory.readInt((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + local3 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 138); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1160, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_3; + } + memory.writeI32((int) ((local2 + 40) + 8) < 0 ? ((local2 + 40) + 8) : ((local2 + 40) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) 0L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 40)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1165, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) 0L); + local3 = 1; + label_6: { + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) (local2 + 24)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1230, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_6; + } + label_7: { + label_8: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 0); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_5[0])) != 0) { + break label_8; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(26, ((int) callResult_6[0])) != 0) { + break label_8; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(1231, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) 216); + long[] callResult_8 = instance.getMachine().call(1776, callArgs_8); + local5 = ((int) callResult_8[0]); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 4, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 50568); + memory.writeLong((int) (local5 + 12) < 0 ? (local5 + 12) : (local5 + 12) + 0, (long) 0L); + memory.writeLong((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0, (long) 0L); + memory.writeI32((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (int) 0); + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 51) & 0xFF); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local3 = (local4 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 44) : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + local6 = (local4 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 40) : (local2 + 40)); + label_9: { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_10; + } + local4 = (local5 + 32); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 43, (byte) (local3)); + break label_9; + } + local7 = ((local3 | 15) + 1); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local7); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + local4 = ((int) callResult_9[0]); + memory.writeI32((int) (local5 + 40) < 0 ? (local5 + 40) : (local5 + 40) + 0, (int) (local7 | -2147483648)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 32, (int) local4); + memory.writeI32((int) (local5 + 36) < 0 ? (local5 + 36) : (local5 + 36) + 0, (int) local3); + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) local3); + callArgs_10[1] = ((long) local6); + callArgs_10[0] = ((long) local4); + long[] callResult_10 = instance.getMachine().call(1891, callArgs_10); + memory.writeByte((int) (((int) callResult_10[0]) + local3) < 0 ? (((int) callResult_10[0]) + local3) : (((int) callResult_10[0]) + local3) + 0, (byte) (0)); + local4 = (local5 + 44); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (0)); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) (local5 + 48)); + long[] callResult_11 = instance.getMachine().call(154, callArgs_11); + memory.writeLong((int) (local5 + 116) < 0 ? (local5 + 116) : (local5 + 116) + 0, (long) 0L); + memory.writeLong((int) (local5 + 108) < 0 ? (local5 + 108) : (local5 + 108) + 0, (long) 0L); + memory.writeLong((int) (local5 + 100) < 0 ? (local5 + 100) : (local5 + 100) + 0, (long) 0L); + memory.writeLong((int) (local5 + 92) < 0 ? (local5 + 92) : (local5 + 92) + 0, (long) 0L); + local6 = (local5 + 84); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) 0L); + memory.writeLong((int) (local5 + 128) < 0 ? (local5 + 128) : (local5 + 128) + 0, (long) 0L); + memory.writeI32((int) (local5 + 124) < 0 ? (local5 + 124) : (local5 + 124) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 136) < 0 ? (local5 + 136) : (local5 + 136) + 0, (long) 0L); + memory.writeLong((int) (local5 + 148) < 0 ? (local5 + 148) : (local5 + 148) + 0, (long) 0L); + memory.writeI32((int) (local5 + 144) < 0 ? (local5 + 144) : (local5 + 144) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 156) < 0 ? (local5 + 156) : (local5 + 156) + 0, (long) 0L); + memory.writeLong((int) (local5 + 164) < 0 ? (local5 + 164) : (local5 + 164) + 0, (long) 0L); + memory.writeLong((int) (local5 + 180) < 0 ? (local5 + 180) : (local5 + 180) + 0, (long) 0L); + memory.writeLong((int) (local5 + 172) < 0 ? (local5 + 172) : (local5 + 172) + 0, (long) 4575657221408423936L); + memory.writeLong((int) (local5 + 188) < 0 ? (local5 + 188) : (local5 + 188) + 0, (long) 0L); + memory.writeLong((int) (local5 + 196) < 0 ? (local5 + 196) : (local5 + 196) + 0, (long) 0L); + memory.writeLong((int) (local5 + 204) < 0 ? (local5 + 204) : (local5 + 204) + 0, (long) 0L); + memory.writeByte((int) (local5 + 212) < 0 ? (local5 + 212) : (local5 + 212) + 0, (byte) (0)); + local3 = 1; + label_11: { + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) 30); + callArgs_12[0] = ((long) arg0); + long[] callResult_12 = instance.getMachine().call(1160, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) != 0) { + break label_11; + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) 26); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(1160, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_13[0])) != 0) { + break label_11; + } + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) 1); + callArgs_14[1] = ((long) (local5 + 4)); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(1196, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])) != 0) { + break label_11; + } + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) 1); + callArgs_15[1] = ((long) (local5 + 16)); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1196, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_15[0])) != 0) { + break label_11; + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) 44); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1160, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_16[0])) != 0) { + break label_11; + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) local4); + callArgs_17[0] = ((long) arg0); + long[] callResult_17 = instance.getMachine().call(1232, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_17[0])) != 0) { + break label_11; + } + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) (local5 + 160)); + callArgs_18[1] = ((long) local6); + callArgs_18[0] = ((long) arg0); + long[] callResult_18 = instance.getMachine().call(1236, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_18[0])) != 0) { + break label_11; + } + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) 16363); + callArgs_19[0] = ((long) (local2 + 80)); + long[] callResult_19 = instance.getMachine().call(1167, callArgs_19); + local4 = ((int) callResult_19[0]); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) 13044); + callArgs_20[0] = ((long) (local4 + 12)); + long[] callResult_20 = instance.getMachine().call(1167, callArgs_20); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) 7082); + callArgs_21[0] = ((long) (local4 + 24)); + long[] callResult_21 = instance.getMachine().call(1167, callArgs_21); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) 3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) local4); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) (local2 + 8)); + callArgs_22[0] = ((long) (local2 + 120)); + long[] callResult_22 = instance.getMachine().call(1168, callArgs_22); + local6 = ((int) callResult_22[0]); + long[] callArgs_23 = new long[3]; + callArgs_23[2] = ((long) 0); + callArgs_23[1] = ((long) local6); + callArgs_23[0] = ((long) arg0); + long[] callResult_23 = instance.getMachine().call(1164, callArgs_23); + local7 = ((int) callResult_23[0]); + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) local6); + long[] callResult_24 = instance.getMachine().call(1169, callArgs_24); + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 35), -1) != 0) { + break label_12; + } + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 24)); + instance.getMachine().call(1777, callArgs_25); + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 23), -1) != 0) { + break label_13; + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 12)); + instance.getMachine().call(1777, callArgs_26); + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_14; + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_27); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7) != 0) { + break label_11; + } + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) arg0); + callArgs_28[0] = ((long) (local2 + 80)); + instance.getMachine().call(1153, callArgs_28); + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) 40); + long[] callResult_29 = instance.getMachine().call(1776, callArgs_29); + local3 = ((int) callResult_29[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local5); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 50208); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 80)); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) memory.readLong((int) (local2 + 88) < 0 ? (local2 + 88) : (local2 + 88) + 0)); + memory.writeI32((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (int) memory.readInt((int) (local2 + 96) < 0 ? (local2 + 96) : (local2 + 96) + 0)); + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) local3); + callArgs_30[0] = ((long) arg1); + instance.getMachine().call(145, callArgs_30); + break label_7; + } + int ciTableIdx_31 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_31 = instance.table(0).requiredRef(ciTableIdx_31); + com.dylibso.chicory.runtime.Instance ciRefInstance_31 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_31), instance); + if (!ciRefInstance_31.type(ciRefInstance_31.functionType(ciFuncId_31)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) local5); + ciRefInstance_31.getMachine().call(ciFuncId_31, callArgs_31); + break label_6; + } + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) 220); + long[] callResult_32 = instance.getMachine().call(1776, callArgs_32); + local5 = ((int) callResult_32[0]); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 4, (long) 0L); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 32, (int) 0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 50672); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 56)); + memory.writeLong((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0, (long) memory.readLong((int) (local2 + 64) < 0 ? (local2 + 64) : (local2 + 64) + 0)); + memory.writeI32((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (int) memory.readInt((int) (local2 + 72) < 0 ? (local2 + 72) : (local2 + 72) + 0)); + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 51) & 0xFF); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local3 = (local6 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 44) : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + local7 = (local6 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 40) : (local2 + 40)); + label_15: { + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_16; + } + local6 = (local5 + 36); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 47, (byte) (local3)); + break label_15; + } + local8 = ((local3 | 15) + 1); + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) local8); + long[] callResult_33 = instance.getMachine().call(1776, callArgs_33); + local6 = ((int) callResult_33[0]); + memory.writeI32((int) (local5 + 44) < 0 ? (local5 + 44) : (local5 + 44) + 0, (int) (local8 | -2147483648)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 36, (int) local6); + memory.writeI32((int) (local5 + 40) < 0 ? (local5 + 40) : (local5 + 40) + 0, (int) local3); + } + long[] callArgs_34 = new long[3]; + callArgs_34[2] = ((long) local3); + callArgs_34[1] = ((long) local7); + callArgs_34[0] = ((long) local6); + long[] callResult_34 = instance.getMachine().call(1891, callArgs_34); + memory.writeByte((int) (((int) callResult_34[0]) + local3) < 0 ? (((int) callResult_34[0]) + local3) : (((int) callResult_34[0]) + local3) + 0, (byte) (0)); + local7 = (local5 + 48); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 0, (byte) (0)); + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) (local5 + 52)); + long[] callResult_35 = instance.getMachine().call(154, callArgs_35); + memory.writeLong((int) (local5 + 120) < 0 ? (local5 + 120) : (local5 + 120) + 0, (long) 0L); + memory.writeLong((int) (local5 + 112) < 0 ? (local5 + 112) : (local5 + 112) + 0, (long) 0L); + memory.writeLong((int) (local5 + 104) < 0 ? (local5 + 104) : (local5 + 104) + 0, (long) 0L); + memory.writeLong((int) (local5 + 96) < 0 ? (local5 + 96) : (local5 + 96) + 0, (long) 0L); + local8 = (local5 + 88); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) 0L); + local9 = (local5 + 132); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) 0L); + memory.writeI32((int) (local5 + 128) < 0 ? (local5 + 128) : (local5 + 128) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 140) < 0 ? (local5 + 140) : (local5 + 140) + 0, (long) 0L); + local10 = (local5 + 152); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 0, (long) 0L); + memory.writeI32((int) (local5 + 148) < 0 ? (local5 + 148) : (local5 + 148) + 0, (int) 1065353216); + memory.writeLong((int) (local5 + 160) < 0 ? (local5 + 160) : (local5 + 160) + 0, (long) 0L); + memory.writeLong((int) (local5 + 168) < 0 ? (local5 + 168) : (local5 + 168) + 0, (long) 0L); + local11 = (local5 + 184); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) 0L); + memory.writeLong((int) (local5 + 176) < 0 ? (local5 + 176) : (local5 + 176) + 0, (long) 4575657221408423936L); + memory.writeLong((int) (local5 + 192) < 0 ? (local5 + 192) : (local5 + 192) + 0, (long) 0L); + memory.writeLong((int) (local5 + 200) < 0 ? (local5 + 200) : (local5 + 200) + 0, (long) 0L); + memory.writeLong((int) (local5 + 208) < 0 ? (local5 + 208) : (local5 + 208) + 0, (long) 0L); + memory.writeByte((int) (local5 + 216) < 0 ? (local5 + 216) : (local5 + 216) + 0, (byte) (0)); + label_17: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_17; + } + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_36[0] = ((long) (local2 + 80)); + instance.getMachine().call(557, callArgs_36); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local6 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) * 40)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 80)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) ((local2 + 80) + 8) < 0 ? ((local2 + 80) + 8) : ((local2 + 80) + 8) + 0)); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) memory.readLong((int) ((local2 + 80) + 16) < 0 ? ((local2 + 80) + 16) : ((local2 + 80) + 16) + 0)); + memory.writeLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0, (long) memory.readLong((int) ((local2 + 80) + 24) < 0 ? ((local2 + 80) + 24) : ((local2 + 80) + 24) + 0)); + memory.writeI32((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0, (int) memory.readInt((int) ((local2 + 80) + 32) < 0 ? ((local2 + 80) + 32) : ((local2 + 80) + 32) + 0)); + label_18: { + if (((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF) != 0) { + break label_18; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_17; + } + local3 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + } + local3 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeLong((int) (local5 + 196) < 0 ? (local5 + 196) : (local5 + 196) + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) (local5 + 212) < 0 ? (local5 + 212) : (local5 + 212) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) (local5 + 204) < 0 ? (local5 + 204) : (local5 + 204) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + local4 = 1; + label_19: { + label_20: { + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) local7); + callArgs_37[0] = ((long) arg0); + long[] callResult_37 = instance.getMachine().call(1232, callArgs_37); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_37[0])) != 0) { + break label_20; + } + local4 = 1; + local3 = (local5 + 164); + local6 = (local5 + 112); + long[] callArgs_38 = new long[6]; + callArgs_38[5] = ((long) 0); + callArgs_38[4] = ((long) local6); + callArgs_38[3] = ((long) local3); + callArgs_38[2] = ((long) local8); + callArgs_38[1] = ((long) 39); + callArgs_38[0] = ((long) arg0); + long[] callResult_38 = instance.getMachine().call(1237, callArgs_38); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_38[0])) != 0) { + break label_20; + } + local4 = 1; + long[] callArgs_39 = new long[4]; + callArgs_39[3] = ((long) local9); + callArgs_39[2] = ((long) (local5 + 100)); + callArgs_39[1] = ((long) 43); + callArgs_39[0] = ((long) arg0); + long[] callResult_39 = instance.getMachine().call(1238, callArgs_39); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_39[0])) != 0) { + break label_20; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 88, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 80, (long) 0L); + local4 = 1; + label_21: { + long[] callArgs_40 = new long[6]; + callArgs_40[5] = ((long) ((memory.readInt((int) (local5 + 92) < 0 ? (local5 + 92) : (local5 + 92) + 0) - memory.readInt((int) local5 < 0 ? local5 : local5 + 88)) >> 3)); + callArgs_40[4] = ((long) local6); + callArgs_40[3] = ((long) local3); + callArgs_40[2] = ((long) (local2 + 80)); + callArgs_40[1] = ((long) 29); + callArgs_40[0] = ((long) arg0); + long[] callResult_40 = instance.getMachine().call(1237, callArgs_40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_40[0])) != 0) { + break label_21; + } + long[] callArgs_41 = new long[2]; + callArgs_41[1] = ((long) (local2 + 80)); + callArgs_41[0] = ((long) local10); + instance.getMachine().call(129, callArgs_41); + local4 = 1; + long[] callArgs_42 = new long[2]; + callArgs_42[1] = ((long) local11); + callArgs_42[0] = ((long) arg0); + long[] callResult_42 = instance.getMachine().call(1173, callArgs_42); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_42[0])) != 0) { + break label_21; + } + long[] callArgs_43 = new long[2]; + callArgs_43[1] = ((long) local5); + callArgs_43[0] = ((long) arg1); + instance.getMachine().call(142, callArgs_43); + local5 = 0; + local4 = 0; + } + label_22: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 80); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_22; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 84, (int) local3); + long[] callArgs_44 = new long[1]; + callArgs_44[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_44); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_19; + } + } + int ciTableIdx_45 = (int) (memory.readInt((int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0) < 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 0) : memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 4)); + int ciFuncId_45 = instance.table(0).requiredRef(ciTableIdx_45); + com.dylibso.chicory.runtime.Instance ciRefInstance_45 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_45), instance); + if (!ciRefInstance_45.type(ciRefInstance_45.functionType(ciFuncId_45)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_45 = new long[1]; + callArgs_45[0] = ((long) local5); + ciRefInstance_45.getMachine().call(ciFuncId_45, callArgs_45); + } + local3 = 1; + if (local4 != 0) { + break label_6; + } + } + local3 = memory.readInt((int) (arg1 + 80) < 0 ? (arg1 + 80) : (arg1 + 80) + 0); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 76); + local5 = memory.readInt((int) (arg1 + 36) < 0 ? (arg1 + 36) : (arg1 + 36) + 0); + memory.writeLong((int) (local2 + 128) < 0 ? (local2 + 128) : (local2 + 128) + 0, (long) memory.readLong((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0)); + memory.writeI32((int) (local2 + 136) < 0 ? (local2 + 136) : (local2 + 136) + 0, (int) memory.readInt((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 120, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 12)); + label_23: { + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_23; + } + local4 = (((local3 - local4) >> 2) + -1); + label_24: while (true) { + long[] callArgs_46 = new long[3]; + callArgs_46[2] = ((long) (local2 + 120)); + callArgs_46[1] = ((long) local4); + callArgs_46[0] = ((long) (local2 + 80)); + long[] callResult_46 = instance.getMachine().call(155, callArgs_46); + local3 = ((int) callResult_46[0]); + long[] callArgs_47 = new long[2]; + callArgs_47[1] = ((long) local3); + callArgs_47[0] = ((long) (local5 + 52)); + long[] callResult_47 = instance.getMachine().call(158, callArgs_47); + long[] callArgs_48 = new long[1]; + callArgs_48[0] = ((long) local3); + long[] callResult_48 = instance.getMachine().call(162, callArgs_48); + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_24; + } + break; + } + } + long[] callArgs_49 = new long[2]; + callArgs_49[1] = ((long) (local2 + 24)); + callArgs_49[0] = ((long) arg1); + instance.getMachine().call(151, callArgs_49); + long[] callArgs_50 = new long[2]; + callArgs_50[1] = ((long) 44); + callArgs_50[0] = ((long) arg0); + long[] callResult_50 = instance.getMachine().call(1160, callArgs_50); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_50[0])); + } + label_25: { + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_25; + } + label_26: while (true) { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + int ciTableIdx_51 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_51 = instance.table(0).requiredRef(ciTableIdx_51); + com.dylibso.chicory.runtime.Instance ciRefInstance_51 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_51), instance); + if (!ciRefInstance_51.type(ciRefInstance_51.functionType(ciFuncId_51)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_51 = new long[1]; + callArgs_51[0] = ((long) arg0); + ciRefInstance_51.getMachine().call(ciFuncId_51, callArgs_51); + arg0 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_26; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 51), -1) != 0) { + break label_3; + } + long[] callArgs_52 = new long[1]; + callArgs_52[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 40)); + instance.getMachine().call(1777, callArgs_52); + } + instance.global(0).setValue(((long) (local2 + 144))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1223(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1223(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1224(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 192); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_3; + } + label_4: { + local4 = (arg0 + 16); + local5 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 152)); + instance.getMachine().call(557, callArgs_1); + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local3 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) * 40)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 152)); + memory.writeLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (long) memory.readLong((int) ((local2 + 152) + 8) < 0 ? ((local2 + 152) + 8) : ((local2 + 152) + 8) + 0)); + memory.writeLong((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (long) memory.readLong((int) ((local2 + 152) + 16) < 0 ? ((local2 + 152) + 16) : ((local2 + 152) + 16) + 0)); + memory.writeLong((int) (local3 + 24) < 0 ? (local3 + 24) : (local3 + 24) + 0, (long) memory.readLong((int) ((local2 + 152) + 24) < 0 ? ((local2 + 152) + 24) : ((local2 + 152) + 24) + 0)); + memory.writeI32((int) (local3 + 32) < 0 ? (local3 + 32) : (local3 + 32) + 0, (int) memory.readInt((int) ((local2 + 152) + 32) < 0 ? ((local2 + 152) + 32) : ((local2 + 152) + 32) + 0)); + label_5: { + if (((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF) != 0) { + break label_5; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + local5 = (local5 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + } + local3 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 40); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local5 = ((int) callResult_2[0]); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 4, (long) 0L); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 32, (long) 4L); + local6 = 47928; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 47928); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 12, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeLong((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeI32((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + local3 = 1; + label_6: { + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 50); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1160, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_6; + } + memory.writeI32((int) ((local2 + 136) + 8) < 0 ? ((local2 + 136) + 8) : ((local2 + 136) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 136, (long) 0L); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 136)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1165, callArgs_4); + local3 = 1; + label_7: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 30); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1160, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_7; + } + label_8: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_8; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_6[0] = ((long) (local2 + 152)); + instance.getMachine().call(557, callArgs_6); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local6 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) * 40)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 152)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) ((local2 + 152) + 8) < 0 ? ((local2 + 152) + 8) : ((local2 + 152) + 8) + 0)); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) memory.readLong((int) ((local2 + 152) + 16) < 0 ? ((local2 + 152) + 16) : ((local2 + 152) + 16) + 0)); + memory.writeLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0, (long) memory.readLong((int) ((local2 + 152) + 24) < 0 ? ((local2 + 152) + 24) : ((local2 + 152) + 24) + 0)); + memory.writeI32((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0, (int) memory.readInt((int) ((local2 + 152) + 32) < 0 ? ((local2 + 152) + 32) : ((local2 + 152) + 32) + 0)); + label_9: { + if (((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF) != 0) { + break label_9; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_8; + } + local3 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + } + local3 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeLong((int) ((local2 + 112) + 8) < 0 ? ((local2 + 112) + 8) : ((local2 + 112) + 8) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeI32((int) ((local2 + 112) + 16) < 0 ? ((local2 + 112) + 16) : ((local2 + 112) + 16) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 112, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + label_10: { + label_11: { + label_12: { + label_13: { + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 0); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1154, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(138, ((int) callResult_7[0])) != 0) { + break label_13; + } + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local6 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) (local6 + 36) < 0 ? (local6 + 36) : (local6 + 36) + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) 108); + long[] callResult_8 = instance.getMachine().call(1776, callArgs_8); + local6 = ((int) callResult_8[0]); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 4, (long) 0L); + memory.writeLong((int) (local6 + 12) < 0 ? (local6 + 12) : (local6 + 12) + 0, (long) 0L); + memory.writeI32((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0, (int) 0); + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 147) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local3 = (local7 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 140) : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + local8 = (local7 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 136) : (local2 + 136)); + label_14: { + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_15; + } + local7 = (local6 + 24); + memory.writeByte((int) local6 < 0 ? local6 : local6 + 35, (byte) (local3)); + break label_14; + } + local9 = ((local3 | 15) + 1); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local9); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + local7 = ((int) callResult_9[0]); + memory.writeI32((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0, (int) (local9 | -2147483648)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) local7); + memory.writeI32((int) (local6 + 28) < 0 ? (local6 + 28) : (local6 + 28) + 0, (int) local3); + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) local3); + callArgs_10[1] = ((long) local8); + callArgs_10[0] = ((long) local7); + long[] callResult_10 = instance.getMachine().call(1891, callArgs_10); + memory.writeByte((int) (((int) callResult_10[0]) + local3) < 0 ? (((int) callResult_10[0]) + local3) : (((int) callResult_10[0]) + local3) + 0, (byte) (0)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 48148); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 40, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 36, (int) 0); + memory.writeLong((int) (local6 + 48) < 0 ? (local6 + 48) : (local6 + 48) + 0, (long) 0L); + memory.writeLong((int) (local6 + 56) < 0 ? (local6 + 56) : (local6 + 56) + 0, (long) 0L); + local3 = (local6 + 64); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + memory.writeLong((int) (local6 + 72) < 0 ? (local6 + 72) : (local6 + 72) + 0, (long) 0L); + local7 = (local6 + 84); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeI32((int) (local6 + 80) < 0 ? (local6 + 80) : (local6 + 80) + 0, (int) 1065353216); + memory.writeLong((int) (local6 + 92) < 0 ? (local6 + 92) : (local6 + 92) + 0, (long) 0L); + memory.writeByte((int) local6 < 0 ? local6 : local6 + 104, (byte) (0)); + memory.writeI32((int) (local6 + 100) < 0 ? (local6 + 100) : (local6 + 100) + 0, (int) 1065353216); + memory.writeLong((int) (local2 + 96) < 0 ? (local2 + 96) : (local2 + 96) + 0, (long) 0L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 88, (long) 0L); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 104, (int) 1065353216); + label_16: { + long[] callArgs_11 = new long[6]; + callArgs_11[5] = ((long) 0); + callArgs_11[4] = ((long) local3); + callArgs_11[3] = ((long) (local2 + 88)); + callArgs_11[2] = ((long) (local6 + 40)); + callArgs_11[1] = ((long) 39); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1237, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + break label_16; + } + long[] callArgs_12 = new long[4]; + callArgs_12[3] = ((long) local7); + callArgs_12[2] = ((long) (local6 + 52)); + callArgs_12[1] = ((long) 43); + callArgs_12[0] = ((long) arg0); + long[] callResult_12 = instance.getMachine().call(1238, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) != 0) { + break label_16; + } + local7 = 0; + memory.writeShort((int) (local2 + 168) < 0 ? (local2 + 168) : (local2 + 168) + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 7086) & 0xFFFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 163, (byte) (5)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 152, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 13044)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 156, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 13048) & 0xFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 175, (byte) (6)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 157, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 164, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 7082)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 170, (byte) (0)); + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) 24); + long[] callResult_13 = instance.getMachine().call(1776, callArgs_13); + local3 = ((int) callResult_13[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 152)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) ((local2 + 152) + 8) < 0 ? ((local2 + 152) + 8) : ((local2 + 152) + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 164)); + memory.writeI32((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (int) memory.readInt((int) ((local2 + 152) + 20) < 0 ? ((local2 + 152) + 20) : ((local2 + 152) + 20) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 72, (int) local3); + local8 = (local3 + 24); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 80, (int) local8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 76, (int) local8); + label_17: { + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) 0); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(1154, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_14[0])) != 0) { + break label_17; + } + local7 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local4 = (local4 + (local7 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local7 ^ 1))); + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) 0); + callArgs_15[1] = ((long) (local2 + 72)); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1163, callArgs_15); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_15[0])); + } + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 23), -1) != 0) { + break label_18; + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 12)); + instance.getMachine().call(1777, callArgs_16); + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 11), -1) != 0) { + break label_19; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + instance.getMachine().call(1777, callArgs_17); + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_18); + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 175), -1) != 0) { + break label_20; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 164)); + instance.getMachine().call(1777, callArgs_19); + } + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 163), -1) != 0) { + break label_21; + } + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 152)); + instance.getMachine().call(1777, callArgs_20); + } + if (local7 != 0) { + break label_16; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 36, (int) local6); + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) (local2 + 88)); + long[] callResult_21 = instance.getMachine().call(1239, callArgs_21); + break label_12; + } + label_22: { + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_22; + } + label_23: while (true) { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 19), -1) != 0) { + break label_24; + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + instance.getMachine().call(1777, callArgs_22); + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_23); + arg0 = local3; + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break; + } + } + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 88); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 88, (int) 0); + label_25: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_25; + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_24); + } + int ciTableIdx_25 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 4)); + int ciFuncId_25 = instance.table(0).requiredRef(ciTableIdx_25); + com.dylibso.chicory.runtime.Instance ciRefInstance_25 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_25), instance); + if (!ciRefInstance_25.type(ciRefInstance_25.functionType(ciFuncId_25)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) local6); + ciRefInstance_25.getMachine().call(ciFuncId_25, callArgs_25); + local3 = 1; + break label_7; + } + label_26: { + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) 0); + callArgs_26[0] = ((long) arg0); + long[] callResult_26 = instance.getMachine().call(1154, callArgs_26); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(47, ((int) callResult_26[0])) != 0) { + break label_26; + } + local6 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local3 = (local4 + (local6 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + local3 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local6 ^ 1))); + label_27: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 13) & 0xFF) != 0) { + break label_27; + } + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) ((local2 + 112) + 16) < 0 ? ((local2 + 112) + 16) : ((local2 + 112) + 16) + 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) ((local2 + 112) + 8) < 0 ? ((local2 + 112) + 8) : ((local2 + 112) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 112)); + long[] callArgs_27 = new long[4]; + callArgs_27[3] = ((long) 0); + callArgs_27[2] = ((long) 18053); + callArgs_27[1] = ((long) (local2 + 8)); + callArgs_27[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_27); + break label_7; + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) 52); + long[] callResult_28 = instance.getMachine().call(1776, callArgs_28); + local3 = ((int) callResult_28[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 35, (byte) (0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) 1); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 50792); + memory.writeLong((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0, (long) 0L); + memory.writeLong((int) (local3 + 17) < 0 ? (local3 + 17) : (local3 + 17) + 0, (long) 0L); + memory.writeI32((int) (local3 + 48) < 0 ? (local3 + 48) : (local3 + 48) + 0, (int) 0); + label_28: { + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) (local3 + 40)); + callArgs_29[0] = ((long) arg0); + long[] callResult_29 = instance.getMachine().call(1240, callArgs_29); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_29[0])) != 0) { + break label_28; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 36, (int) local3); + break label_12; + } + int ciTableIdx_30 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_30 = instance.table(0).requiredRef(ciTableIdx_30); + com.dylibso.chicory.runtime.Instance ciRefInstance_30 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_30), instance); + if (!ciRefInstance_30.type(ciRefInstance_30.functionType(ciFuncId_30)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) local3); + ciRefInstance_30.getMachine().call(ciFuncId_30, callArgs_30); + local3 = 1; + break label_7; + } + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) 0); + callArgs_31[0] = ((long) arg0); + long[] callResult_31 = instance.getMachine().call(1154, callArgs_31); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(2, ((int) callResult_31[0])) != 0) { + break label_10; + } + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local4 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeByte((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + label_29: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 13) & 0xFF) != 0) { + break label_29; + } + memory.writeI32((int) ((local2 + 32) + 16) < 0 ? ((local2 + 32) + 16) : ((local2 + 32) + 16) + 0, (int) memory.readInt((int) ((local2 + 112) + 16) < 0 ? ((local2 + 112) + 16) : ((local2 + 112) + 16) + 0)); + memory.writeLong((int) ((local2 + 32) + 8) < 0 ? ((local2 + 32) + 8) : ((local2 + 32) + 8) + 0, (long) memory.readLong((int) ((local2 + 112) + 8) < 0 ? ((local2 + 112) + 8) : ((local2 + 112) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 112)); + long[] callArgs_32 = new long[4]; + callArgs_32[3] = ((long) 0); + callArgs_32[2] = ((long) 18465); + callArgs_32[1] = ((long) (local2 + 32)); + callArgs_32[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_32); + } + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) (local2 + 136)); + long[] callResult_33 = instance.getMachine().call(1241, callArgs_33); + local4 = ((int) callResult_33[0]); + long[] callArgs_34 = new long[2]; + callArgs_34[1] = ((long) (local4 + 40)); + callArgs_34[0] = ((long) arg0); + long[] callResult_34 = instance.getMachine().call(1242, callArgs_34); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_34[0])) != 0) { + break label_11; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 36, (int) local4); + } + local3 = 1; + long[] callArgs_35 = new long[2]; + callArgs_35[1] = ((long) 44); + callArgs_35[0] = ((long) arg0); + long[] callResult_35 = instance.getMachine().call(1160, callArgs_35); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_35[0])) != 0) { + break label_7; + } + local3 = 1; + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) 44); + callArgs_36[0] = ((long) arg0); + long[] callResult_36 = instance.getMachine().call(1160, callArgs_36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_36[0])) != 0) { + break label_7; + } + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) local5); + callArgs_37[0] = ((long) arg1); + instance.getMachine().call(143, callArgs_37); + local5 = 0; + local3 = 0; + break label_7; + } + local3 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_7; + } + int ciTableIdx_38 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_38 = instance.table(0).requiredRef(ciTableIdx_38); + com.dylibso.chicory.runtime.Instance ciRefInstance_38 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_38), instance); + if (!ciRefInstance_38.type(ciRefInstance_38.functionType(ciFuncId_38)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_38 = new long[1]; + callArgs_38[0] = ((long) local4); + ciRefInstance_38.getMachine().call(ciFuncId_38, callArgs_38); + break label_7; + } + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) 26480); + callArgs_39[0] = ((long) (local2 + 152)); + long[] callResult_39 = instance.getMachine().call(1167, callArgs_39); + local4 = ((int) callResult_39[0]); + long[] callArgs_40 = new long[2]; + callArgs_40[1] = ((long) 7364); + callArgs_40[0] = ((long) (local4 + 12)); + long[] callResult_40 = instance.getMachine().call(1167, callArgs_40); + long[] callArgs_41 = new long[2]; + callArgs_41[1] = ((long) 1310); + callArgs_41[0] = ((long) (local4 + 24)); + long[] callResult_41 = instance.getMachine().call(1167, callArgs_41); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 68, (int) 3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 64, (int) local4); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 56, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + long[] callArgs_42 = new long[2]; + callArgs_42[1] = ((long) (local2 + 56)); + callArgs_42[0] = ((long) (local2 + 88)); + long[] callResult_42 = instance.getMachine().call(1168, callArgs_42); + local6 = ((int) callResult_42[0]); + long[] callArgs_43 = new long[3]; + callArgs_43[2] = ((long) 0); + callArgs_43[1] = ((long) local6); + callArgs_43[0] = ((long) arg0); + long[] callResult_43 = instance.getMachine().call(1163, callArgs_43); + local3 = ((int) callResult_43[0]); + long[] callArgs_44 = new long[1]; + callArgs_44[0] = ((long) local6); + long[] callResult_44 = instance.getMachine().call(1169, callArgs_44); + label_30: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 35), -1) != 0) { + break label_30; + } + long[] callArgs_45 = new long[1]; + callArgs_45[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 24)); + instance.getMachine().call(1777, callArgs_45); + } + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 23), -1) != 0) { + break label_31; + } + long[] callArgs_46 = new long[1]; + callArgs_46[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 12)); + instance.getMachine().call(1777, callArgs_46); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_7; + } + long[] callArgs_47 = new long[1]; + callArgs_47[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_47); + } + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 147), -1) != 0) { + break label_32; + } + long[] callArgs_48 = new long[1]; + callArgs_48[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 136)); + instance.getMachine().call(1777, callArgs_48); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + } + int ciTableIdx_49 = (int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 4)); + int ciFuncId_49 = instance.table(0).requiredRef(ciTableIdx_49); + com.dylibso.chicory.runtime.Instance ciRefInstance_49 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_49), instance); + if (!ciRefInstance_49.type(ciRefInstance_49.functionType(ciFuncId_49)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_49 = new long[1]; + callArgs_49[0] = ((long) local5); + ciRefInstance_49.getMachine().call(ciFuncId_49, callArgs_49); + } + instance.global(0).setValue(((long) (local2 + 192))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1224(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1224(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1225(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + label_2: { + local3 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 64)); + instance.getMachine().call(557, callArgs_1); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 64) + 8) < 0 ? ((local2 + 64) + 8) : ((local2 + 64) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 64) + 16) < 0 ? ((local2 + 64) + 16) : ((local2 + 64) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 64) + 24) < 0 ? ((local2 + 64) + 24) : ((local2 + 64) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 64) + 32) < 0 ? ((local2 + 64) + 32) : ((local2 + 64) + 32) + 0)); + label_3: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + label_4: { + label_5: { + label_6: { + label_7: { + local4 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_7; + } + memory.writeLong((int) ((local2 + 40) + 8) < 0 ? ((local2 + 40) + 8) : ((local2 + 40) + 8) + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeI32((int) ((local2 + 40) + 16) < 0 ? ((local2 + 40) + 16) : ((local2 + 40) + 16) + 0, (int) memory.readInt((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 40, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + local3 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 25); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1160, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_1; + } + memory.writeI32((int) ((local2 + 24) + 8) < 0 ? ((local2 + 24) + 8) : ((local2 + 24) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 24, (long) 0L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 24)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1165, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) 0L); + local3 = 1; + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 3); + callArgs_4[1] = ((long) (local2 + 8)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1230, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_4; + } + label_8: { + label_9: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 0); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_5[0])) != 0) { + break label_9; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(26, ((int) callResult_6[0])) != 0) { + break label_9; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(1231, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) 68); + long[] callResult_8 = instance.getMachine().call(1776, callArgs_8); + local4 = ((int) callResult_8[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) 3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 50888); + memory.writeLong((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (long) 0L); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) 0L); + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 35) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local3 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 28) : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_6; + } + local6 = (local4 + 32); + local7 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 24) : (local2 + 24)); + label_10: { + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_11; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 43, (byte) (local3)); + local5 = local6; + break label_10; + } + local8 = ((local3 | 15) + 1); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local8); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + local5 = ((int) callResult_9[0]); + memory.writeI32((int) (local4 + 40) < 0 ? (local4 + 40) : (local4 + 40) + 0, (int) (local8 | -2147483648)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) local5); + memory.writeI32((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0, (int) local3); + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) local3); + callArgs_10[1] = ((long) local7); + callArgs_10[0] = ((long) local5); + long[] callResult_10 = instance.getMachine().call(1891, callArgs_10); + memory.writeByte((int) (((int) callResult_10[0]) + local3) < 0 ? (((int) callResult_10[0]) + local3) : (((int) callResult_10[0]) + local3) + 0, (byte) (0)); + memory.writeI32((int) (local4 + 64) < 0 ? (local4 + 64) : (local4 + 64) + 0, (int) 0); + memory.writeLong((int) (local4 + 56) < 0 ? (local4 + 56) : (local4 + 56) + 0, (long) 0L); + memory.writeByte((int) (local4 + 52) < 0 ? (local4 + 52) : (local4 + 52) + 0, (byte) (0)); + memory.writeLong((int) (local4 + 44) < 0 ? (local4 + 44) : (local4 + 44) + 0, (long) -64L); + local3 = 1; + label_12: { + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 30); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1160, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + break label_12; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) 26); + callArgs_12[0] = ((long) arg0); + long[] callResult_12 = instance.getMachine().call(1160, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) != 0) { + break label_12; + } + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) 1); + callArgs_13[1] = ((long) (local4 + 4)); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(1196, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_13[0])) != 0) { + break label_12; + } + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) 1); + callArgs_14[1] = ((long) (local4 + 16)); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(1196, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])) != 0) { + break label_12; + } + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) 44); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1160, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_15[0])) != 0) { + break label_12; + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) local6); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1243, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_16[0])) != 0) { + break label_12; + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) arg0); + callArgs_17[0] = ((long) (local2 + 64)); + instance.getMachine().call(1153, callArgs_17); + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) 40); + long[] callResult_18 = instance.getMachine().call(1776, callArgs_18); + local3 = ((int) callResult_18[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 50208); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) memory.readLong((int) (local2 + 72) < 0 ? (local2 + 72) : (local2 + 72) + 0)); + memory.writeI32((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (int) memory.readInt((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0)); + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) local3); + callArgs_19[0] = ((long) arg1); + instance.getMachine().call(145, callArgs_19); + break label_8; + } + int ciTableIdx_20 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_20 = instance.table(0).requiredRef(ciTableIdx_20); + com.dylibso.chicory.runtime.Instance ciRefInstance_20 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_20), instance); + if (!ciRefInstance_20.type(ciRefInstance_20.functionType(ciFuncId_20)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) local4); + ciRefInstance_20.getMachine().call(ciFuncId_20, callArgs_20); + break label_4; + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) 72); + long[] callResult_21 = instance.getMachine().call(1776, callArgs_21); + local4 = ((int) callResult_21[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 50996); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 40)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (local2 + 48) < 0 ? (local2 + 48) : (local2 + 48) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local2 + 56) < 0 ? (local2 + 56) : (local2 + 56) + 0)); + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 35) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local3 = (local7 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 28) : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_6; + } + local5 = (local4 + 36); + local6 = (local7 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 24) : (local2 + 24)); + label_13: { + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_14; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 47, (byte) (local3)); + local7 = local5; + break label_13; + } + local8 = ((local3 | 15) + 1); + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) local8); + long[] callResult_22 = instance.getMachine().call(1776, callArgs_22); + local7 = ((int) callResult_22[0]); + memory.writeI32((int) (local4 + 44) < 0 ? (local4 + 44) : (local4 + 44) + 0, (int) (local8 | -2147483648)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) local7); + memory.writeI32((int) (local4 + 40) < 0 ? (local4 + 40) : (local4 + 40) + 0, (int) local3); + } + long[] callArgs_23 = new long[3]; + callArgs_23[2] = ((long) local3); + callArgs_23[1] = ((long) local6); + callArgs_23[0] = ((long) local7); + long[] callResult_23 = instance.getMachine().call(1891, callArgs_23); + memory.writeByte((int) (((int) callResult_23[0]) + local3) < 0 ? (((int) callResult_23[0]) + local3) : (((int) callResult_23[0]) + local3) + 0, (byte) (0)); + memory.writeI32((int) (local4 + 68) < 0 ? (local4 + 68) : (local4 + 68) + 0, (int) 0); + local7 = (local4 + 60); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeByte((int) (local4 + 56) < 0 ? (local4 + 56) : (local4 + 56) + 0, (byte) (0)); + memory.writeLong((int) (local4 + 48) < 0 ? (local4 + 48) : (local4 + 48) + 0, (long) -64L); + local3 = 1; + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) local5); + callArgs_24[0] = ((long) arg0); + long[] callResult_24 = instance.getMachine().call(1243, callArgs_24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_24[0])) != 0) { + break label_5; + } + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) local7); + callArgs_25[0] = ((long) arg0); + long[] callResult_25 = instance.getMachine().call(1173, callArgs_25); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_25[0])) != 0) { + break label_5; + } + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) local4); + callArgs_26[0] = ((long) arg1); + instance.getMachine().call(144, callArgs_26); + } + local3 = memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 88); + local4 = memory.readInt((int) (arg1 + 36) < 0 ? (arg1 + 36) : (arg1 + 36) + 0); + memory.writeLong((int) (local2 + 112) < 0 ? (local2 + 112) : (local2 + 112) + 0, (long) memory.readLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0)); + memory.writeI32((int) (local2 + 120) < 0 ? (local2 + 120) : (local2 + 120) + 0, (int) memory.readInt((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 104, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 12)); + label_15: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_15; + } + local5 = (((local3 - local5) >> 2) + -1); + label_16: while (true) { + long[] callArgs_27 = new long[3]; + callArgs_27[2] = ((long) (local2 + 104)); + callArgs_27[1] = ((long) local5); + callArgs_27[0] = ((long) (local2 + 64)); + long[] callResult_27 = instance.getMachine().call(155, callArgs_27); + local3 = ((int) callResult_27[0]); + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) local3); + callArgs_28[0] = ((long) (local4 + 52)); + long[] callResult_28 = instance.getMachine().call(158, callArgs_28); + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) local3); + long[] callResult_29 = instance.getMachine().call(162, callArgs_29); + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + break; + } + } + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) (local2 + 8)); + callArgs_30[0] = ((long) arg1); + instance.getMachine().call(151, callArgs_30); + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) 44); + callArgs_31[0] = ((long) arg0); + long[] callResult_31 = instance.getMachine().call(1160, callArgs_31); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_31[0])); + break label_4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + int ciTableIdx_34 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_34 = instance.table(0).requiredRef(ciTableIdx_34); + com.dylibso.chicory.runtime.Instance ciRefInstance_34 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_34), instance); + if (!ciRefInstance_34.type(ciRefInstance_34.functionType(ciFuncId_34)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) local4); + ciRefInstance_34.getMachine().call(ciFuncId_34, callArgs_34); + } + label_17: { + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_17; + } + label_18: while (true) { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + int ciTableIdx_35 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_35 = instance.table(0).requiredRef(ciTableIdx_35); + com.dylibso.chicory.runtime.Instance ciRefInstance_35 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_35), instance); + if (!ciRefInstance_35.type(ciRefInstance_35.functionType(ciFuncId_35)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) arg0); + ciRefInstance_35.getMachine().call(ciFuncId_35, callArgs_35); + arg0 = local4; + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 35), -1) != 0) { + break label_1; + } + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 24)); + instance.getMachine().call(1777, callArgs_36); + } + instance.global(0).setValue(((long) (local2 + 128))); + return local3; + } + + public static long[] call_1225(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1225(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1226(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_2; + } + label_3: { + local4 = (arg0 + 16); + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 120)); + instance.getMachine().call(557, callArgs_1); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 120)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 120) + 8) < 0 ? ((local2 + 120) + 8) : ((local2 + 120) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 120) + 16) < 0 ? ((local2 + 120) + 16) : ((local2 + 120) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 120) + 24) < 0 ? ((local2 + 120) + 24) : ((local2 + 120) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 120) + 32) < 0 ? ((local2 + 120) + 32) : ((local2 + 120) + 32) + 0)); + label_4: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_4; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + local3 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + } + local3 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeLong((int) ((local2 + 96) + 8) < 0 ? ((local2 + 96) + 8) : ((local2 + 96) + 8) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + memory.writeI32((int) ((local2 + 96) + 16) < 0 ? ((local2 + 96) + 16) : ((local2 + 96) + 16) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 96, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1231, callArgs_2); + local3 = 1; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 26); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1160, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_2; + } + memory.writeI32((int) ((local2 + 80) + 8) < 0 ? ((local2 + 80) + 8) : ((local2 + 80) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 80, (long) 0L); + memory.writeI32((int) ((local2 + 64) + 8) < 0 ? ((local2 + 64) + 8) : ((local2 + 64) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 64, (long) 0L); + local3 = 1; + label_5: { + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 1); + callArgs_4[1] = ((long) (local2 + 80)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1196, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_5; + } + local3 = 1; + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 1); + callArgs_5[1] = ((long) (local2 + 64)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1196, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_5; + } + local3 = 1; + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 30); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1160, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_6[0])) != 0) { + break label_5; + } + memory.writeI32((int) (local2 + 56) < 0 ? (local2 + 56) : (local2 + 56) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) 0L); + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + label_13: { + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 0); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1154, callArgs_7); + local3 = ((int) callResult_7[0]); + switch((local3 + -20)) { + case 0: + { + break label_9; + } + case 1: + { + break label_8; + } + case 2: + { + break label_8; + } + case 3: + { + break label_8; + } + case 4: + { + break label_8; + } + case 5: + { + break label_10; + } + case 6: + { + break label_8; + } + case 7: + { + break label_8; + } + case 8: + { + break label_8; + } + case 9: + { + break label_8; + } + case 10: + { + break label_8; + } + case 11: + { + break label_11; + } + case 12: + { + break label_8; + } + case 13: + { + break label_8; + } + case 14: + { + break label_8; + } + case 15: + { + break label_8; + } + case 16: + { + break label_8; + } + case 17: + { + break label_8; + } + case 18: + { + break label_8; + } + case 19: + { + break label_8; + } + case 20: + { + break label_8; + } + case 21: + { + break label_8; + } + case 22: + { + break label_8; + } + case 23: + { + break label_8; + } + case 24: + { + break label_8; + } + case 25: + { + break label_8; + } + case 26: + { + break label_8; + } + case 27: + { + break label_8; + } + case 28: + { + break label_12; + } + default: + { + break label_13; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(138, local3) != 0) { + break label_8; + } + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local3 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + local3 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) (local2 + 48)); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1165, callArgs_8); + label_14: { + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) (local2 + 48)); + long[] callResult_9 = instance.getMachine().call(1244, callArgs_9); + local4 = ((int) callResult_9[0]); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) (local4 + 44)); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1232, callArgs_10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_10[0])) != 0) { + break label_14; + } + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local4 + 160)); + callArgs_11[1] = ((long) (local4 + 84)); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1236, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + break label_14; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) 13044); + callArgs_12[0] = ((long) (local2 + 120)); + long[] callResult_12 = instance.getMachine().call(1167, callArgs_12); + local5 = ((int) callResult_12[0]); + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) 7082); + callArgs_13[0] = ((long) (local5 + 12)); + long[] callResult_13 = instance.getMachine().call(1167, callArgs_13); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 28, (int) 2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local5); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 24)); + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) (local2 + 8)); + callArgs_14[0] = ((long) (local2 + 32)); + long[] callResult_14 = instance.getMachine().call(1168, callArgs_14); + local6 = ((int) callResult_14[0]); + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) 0); + callArgs_15[1] = ((long) local6); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1164, callArgs_15); + local7 = ((int) callResult_15[0]); + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) local6); + long[] callResult_16 = instance.getMachine().call(1169, callArgs_16); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 23), -1) != 0) { + break label_15; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 12)); + instance.getMachine().call(1777, callArgs_17); + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 11), -1) != 0) { + break label_16; + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + instance.getMachine().call(1777, callArgs_18); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7) != 0) { + break label_14; + } + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) 44); + callArgs_19[0] = ((long) arg0); + long[] callResult_19 = instance.getMachine().call(1160, callArgs_19); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_19[0])) != 0) { + break label_7; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_6; + } + int ciTableIdx_20 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_20 = instance.table(0).requiredRef(ciTableIdx_20); + com.dylibso.chicory.runtime.Instance ciRefInstance_20 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_20), instance); + if (!ciRefInstance_20.type(ciRefInstance_20.functionType(ciFuncId_20)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) local4); + ciRefInstance_20.getMachine().call(ciFuncId_20, callArgs_20); + break label_6; + } + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local3 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + local3 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) (local2 + 48)); + callArgs_21[0] = ((long) arg0); + long[] callResult_21 = instance.getMachine().call(1165, callArgs_21); + label_17: { + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) (local2 + 48)); + long[] callResult_22 = instance.getMachine().call(1245, callArgs_22); + local4 = ((int) callResult_22[0]); + local5 = (local4 + 48); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) local5); + callArgs_23[0] = ((long) arg0); + long[] callResult_23 = instance.getMachine().call(1200, callArgs_23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_23[0])) != 0) { + break label_17; + } + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) local5); + callArgs_24[0] = ((long) arg0); + long[] callResult_24 = instance.getMachine().call(1201, callArgs_24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_24[0])) != 0) { + break label_17; + } + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) (local4 + 72)); + callArgs_25[0] = ((long) arg0); + long[] callResult_25 = instance.getMachine().call(1195, callArgs_25); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_25[0])) != 0) { + break label_17; + } + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) 44); + callArgs_26[0] = ((long) arg0); + long[] callResult_26 = instance.getMachine().call(1160, callArgs_26); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_26[0])) != 0) { + break label_7; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_6; + } + int ciTableIdx_27 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_27 = instance.table(0).requiredRef(ciTableIdx_27); + com.dylibso.chicory.runtime.Instance ciRefInstance_27 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_27), instance); + if (!ciRefInstance_27.type(ciRefInstance_27.functionType(ciFuncId_27)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) local4); + ciRefInstance_27.getMachine().call(ciFuncId_27, callArgs_27); + break label_6; + } + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local3 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + local3 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) (local2 + 48)); + callArgs_28[0] = ((long) arg0); + long[] callResult_28 = instance.getMachine().call(1165, callArgs_28); + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) (local2 + 48)); + long[] callResult_29 = instance.getMachine().call(1246, callArgs_29); + local4 = ((int) callResult_29[0]); + local6 = (local4 + 72); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 65536); + label_18: { + local5 = (local4 + 48); + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) local5); + callArgs_30[0] = ((long) arg0); + long[] callResult_30 = instance.getMachine().call(1200, callArgs_30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_30[0])) != 0) { + break label_18; + } + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) local5); + callArgs_31[0] = ((long) arg0); + long[] callResult_31 = instance.getMachine().call(1201, callArgs_31); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_31[0])) != 0) { + break label_18; + } + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) local6); + callArgs_32[0] = ((long) arg0); + long[] callResult_32 = instance.getMachine().call(1203, callArgs_32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_32[0])) != 0) { + break label_18; + } + long[] callArgs_33 = new long[2]; + callArgs_33[1] = ((long) 44); + callArgs_33[0] = ((long) arg0); + long[] callResult_33 = instance.getMachine().call(1160, callArgs_33); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_33[0])) != 0) { + break label_7; + } + } + int ciTableIdx_34 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_34 = instance.table(0).requiredRef(ciTableIdx_34); + com.dylibso.chicory.runtime.Instance ciRefInstance_34 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_34), instance); + if (!ciRefInstance_34.type(ciRefInstance_34.functionType(ciFuncId_34)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) local4); + ciRefInstance_34.getMachine().call(ciFuncId_34, callArgs_34); + break label_6; + } + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local3 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + local3 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + long[] callArgs_35 = new long[2]; + callArgs_35[1] = ((long) (local2 + 48)); + callArgs_35[0] = ((long) arg0); + long[] callResult_35 = instance.getMachine().call(1165, callArgs_35); + label_19: { + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) (local2 + 48)); + long[] callResult_36 = instance.getMachine().call(1247, callArgs_36); + local4 = ((int) callResult_36[0]); + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) (local4 + 32)); + callArgs_37[0] = ((long) arg0); + long[] callResult_37 = instance.getMachine().call(1243, callArgs_37); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_37[0])) != 0) { + break label_19; + } + long[] callArgs_38 = new long[2]; + callArgs_38[1] = ((long) 44); + callArgs_38[0] = ((long) arg0); + long[] callResult_38 = instance.getMachine().call(1160, callArgs_38); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_38[0])) != 0) { + break label_7; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_6; + } + int ciTableIdx_39 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_39 = instance.table(0).requiredRef(ciTableIdx_39); + com.dylibso.chicory.runtime.Instance ciRefInstance_39 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_39), instance); + if (!ciRefInstance_39.type(ciRefInstance_39.functionType(ciFuncId_39)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_39 = new long[1]; + callArgs_39[0] = ((long) local4); + ciRefInstance_39.getMachine().call(ciFuncId_39, callArgs_39); + break label_6; + } + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local3 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + local3 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + long[] callArgs_40 = new long[2]; + callArgs_40[1] = ((long) (local2 + 48)); + callArgs_40[0] = ((long) arg0); + long[] callResult_40 = instance.getMachine().call(1165, callArgs_40); + label_20: { + long[] callArgs_41 = new long[1]; + callArgs_41[0] = ((long) (local2 + 48)); + long[] callResult_41 = instance.getMachine().call(1248, callArgs_41); + local4 = ((int) callResult_41[0]); + long[] callArgs_42 = new long[2]; + callArgs_42[1] = ((long) (local4 + 44)); + callArgs_42[0] = ((long) arg0); + long[] callResult_42 = instance.getMachine().call(1232, callArgs_42); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_42[0])) != 0) { + break label_20; + } + long[] callArgs_43 = new long[2]; + callArgs_43[1] = ((long) (local4 + 84)); + callArgs_43[0] = ((long) arg0); + long[] callResult_43 = instance.getMachine().call(1233, callArgs_43); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_43[0])) != 0) { + break label_20; + } + long[] callArgs_44 = new long[2]; + callArgs_44[1] = ((long) 44); + callArgs_44[0] = ((long) arg0); + long[] callResult_44 = instance.getMachine().call(1160, callArgs_44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_44[0])) != 0) { + break label_7; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_6; + } + int ciTableIdx_45 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_45 = instance.table(0).requiredRef(ciTableIdx_45); + com.dylibso.chicory.runtime.Instance ciRefInstance_45 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_45), instance); + if (!ciRefInstance_45.type(ciRefInstance_45.functionType(ciFuncId_45)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_45 = new long[1]; + callArgs_45[0] = ((long) local4); + ciRefInstance_45.getMachine().call(ciFuncId_45, callArgs_45); + break label_6; + } + long[] callArgs_46 = new long[2]; + callArgs_46[1] = ((long) 17677); + callArgs_46[0] = ((long) (local2 + 32)); + long[] callResult_46 = instance.getMachine().call(1167, callArgs_46); + arg1 = ((int) callResult_46[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 20, (int) 1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) arg1); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 16)); + long[] callArgs_47 = new long[2]; + callArgs_47[1] = ((long) local2); + callArgs_47[0] = ((long) (local2 + 120)); + long[] callResult_47 = instance.getMachine().call(1168, callArgs_47); + local4 = ((int) callResult_47[0]); + long[] callArgs_48 = new long[3]; + callArgs_48[2] = ((long) 0); + callArgs_48[1] = ((long) local4); + callArgs_48[0] = ((long) arg0); + long[] callResult_48 = instance.getMachine().call(1163, callArgs_48); + local3 = ((int) callResult_48[0]); + long[] callArgs_49 = new long[1]; + callArgs_49[0] = ((long) local4); + long[] callResult_49 = instance.getMachine().call(1169, callArgs_49); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_6; + } + long[] callArgs_50 = new long[1]; + callArgs_50[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_50); + break label_6; + } + long[] callArgs_51 = new long[1]; + callArgs_51[0] = ((long) 40); + long[] callResult_51 = instance.getMachine().call(1776, callArgs_51); + local3 = ((int) callResult_51[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 50208); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 96)); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) memory.readLong((int) (local2 + 104) < 0 ? (local2 + 104) : (local2 + 104) + 0)); + memory.writeI32((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (int) memory.readInt((int) ((local2 + 96) + 16) < 0 ? ((local2 + 96) + 16) : ((local2 + 96) + 16) + 0)); + long[] callArgs_52 = new long[2]; + callArgs_52[1] = ((long) (local2 + 80)); + callArgs_52[0] = ((long) (local4 + 4)); + long[] callResult_52 = instance.getMachine().call(1249, callArgs_52); + long[] callArgs_53 = new long[2]; + callArgs_53[1] = ((long) (local2 + 64)); + callArgs_53[0] = ((long) (memory.readInt((int) local3 < 0 ? local3 : local3 + 36) + 16)); + long[] callResult_53 = instance.getMachine().call(1249, callArgs_53); + long[] callArgs_54 = new long[2]; + callArgs_54[1] = ((long) local3); + callArgs_54[0] = ((long) arg1); + instance.getMachine().call(145, callArgs_54); + long[] callArgs_55 = new long[2]; + callArgs_55[1] = ((long) 44); + callArgs_55[0] = ((long) arg0); + long[] callResult_55 = instance.getMachine().call(1160, callArgs_55); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_55[0])); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 59), -1) != 0) { + break label_5; + } + long[] callArgs_56 = new long[1]; + callArgs_56[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 48)); + instance.getMachine().call(1777, callArgs_56); + } + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 75), -1) != 0) { + break label_21; + } + long[] callArgs_57 = new long[1]; + callArgs_57[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 64)); + instance.getMachine().call(1777, callArgs_57); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 91), -1) != 0) { + break label_2; + } + long[] callArgs_58 = new long[1]; + callArgs_58[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 80)); + instance.getMachine().call(1777, callArgs_58); + } + instance.global(0).setValue(((long) (local2 + 160))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1226(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1226(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1227(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_3; + } + label_4: { + local3 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 104)); + instance.getMachine().call(557, callArgs_1); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 104) + 8) < 0 ? ((local2 + 104) + 8) : ((local2 + 104) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 104) + 16) < 0 ? ((local2 + 104) + 16) : ((local2 + 104) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 104) + 24) < 0 ? ((local2 + 104) + 24) : ((local2 + 104) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 104) + 32) < 0 ? ((local2 + 104) + 32) : ((local2 + 104) + 32) + 0)); + label_5: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_5; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + local4 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeLong((int) ((local2 + 80) + 8) < 0 ? ((local2 + 80) + 8) : ((local2 + 80) + 8) + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeI32((int) ((local2 + 80) + 16) < 0 ? ((local2 + 80) + 16) : ((local2 + 80) + 16) + 0, (int) memory.readInt((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 80, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + local3 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 31); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1160, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_3; + } + memory.writeI32((int) ((local2 + 64) + 8) < 0 ? ((local2 + 64) + 8) : ((local2 + 64) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 64, (long) 0L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 64)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1165, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) 0L); + local3 = 1; + label_6: { + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 2); + callArgs_4[1] = ((long) (local2 + 48)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1230, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_6; + } + label_7: { + label_8: { + label_9: { + label_10: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 0); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_5[0])) != 0) { + break label_10; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(26, ((int) callResult_6[0])) != 0) { + break label_10; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(1231, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) 80); + long[] callResult_8 = instance.getMachine().call(1776, callArgs_8); + local4 = ((int) callResult_8[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) 2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 51224); + memory.writeLong((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (long) 0L); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) 0L); + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 75) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local3 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 68) : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + local6 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 64) : (local2 + 64)); + label_11: { + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_12; + } + local5 = (local4 + 32); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 43, (byte) (local3)); + break label_11; + } + local7 = ((local3 | 15) + 1); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local7); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + local5 = ((int) callResult_9[0]); + memory.writeI32((int) (local4 + 40) < 0 ? (local4 + 40) : (local4 + 40) + 0, (int) (local7 | -2147483648)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) local5); + memory.writeI32((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0, (int) local3); + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) local3); + callArgs_10[1] = ((long) local6); + callArgs_10[0] = ((long) local5); + long[] callResult_10 = instance.getMachine().call(1891, callArgs_10); + memory.writeByte((int) (((int) callResult_10[0]) + local3) < 0 ? (((int) callResult_10[0]) + local3) : (((int) callResult_10[0]) + local3) + 0, (byte) (0)); + memory.writeI32((int) (local4 + 63) < 0 ? (local4 + 63) : (local4 + 63) + 0, (int) 0); + memory.writeLong((int) (local4 + 56) < 0 ? (local4 + 56) : (local4 + 56) + 0, (long) 0L); + local5 = (local4 + 48); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + local6 = (local4 + 72); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 65536); + local3 = 1; + label_13: { + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 30); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1160, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + break label_13; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) 26); + callArgs_12[0] = ((long) arg0); + long[] callResult_12 = instance.getMachine().call(1160, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) != 0) { + break label_13; + } + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) 1); + callArgs_13[1] = ((long) (local4 + 4)); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(1196, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_13[0])) != 0) { + break label_13; + } + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) 1); + callArgs_14[1] = ((long) (local4 + 16)); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(1196, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])) != 0) { + break label_13; + } + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) 44); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1160, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_15[0])) != 0) { + break label_13; + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) local5); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1200, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_16[0])) != 0) { + break label_13; + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) local5); + callArgs_17[0] = ((long) arg0); + long[] callResult_17 = instance.getMachine().call(1201, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_17[0])) != 0) { + break label_13; + } + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) local6); + callArgs_18[0] = ((long) arg0); + long[] callResult_18 = instance.getMachine().call(1203, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_18[0])) != 0) { + break label_13; + } + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) arg0); + callArgs_19[0] = ((long) (local2 + 104)); + instance.getMachine().call(1153, callArgs_19); + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) 40); + long[] callResult_20 = instance.getMachine().call(1776, callArgs_20); + local3 = ((int) callResult_20[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 50208); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) memory.readLong((int) (local2 + 112) < 0 ? (local2 + 112) : (local2 + 112) + 0)); + memory.writeI32((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (int) memory.readInt((int) (local2 + 120) < 0 ? (local2 + 120) : (local2 + 120) + 0)); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) local3); + callArgs_21[0] = ((long) arg1); + instance.getMachine().call(145, callArgs_21); + break label_9; + } + int ciTableIdx_22 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_22 = instance.table(0).requiredRef(ciTableIdx_22); + com.dylibso.chicory.runtime.Instance ciRefInstance_22 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_22), instance); + if (!ciRefInstance_22.type(ciRefInstance_22.functionType(ciFuncId_22)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) local4); + ciRefInstance_22.getMachine().call(ciFuncId_22, callArgs_22); + break label_6; + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) 88); + long[] callResult_23 = instance.getMachine().call(1776, callArgs_23); + local4 = ((int) callResult_23[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 7); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 51332); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 80)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (local2 + 88) < 0 ? (local2 + 88) : (local2 + 88) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local2 + 96) < 0 ? (local2 + 96) : (local2 + 96) + 0)); + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 75) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local3 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 68) : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + local6 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 64) : (local2 + 64)); + label_14: { + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_15; + } + local5 = (local4 + 40); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 51, (byte) (local3)); + break label_14; + } + local7 = ((local3 | 15) + 1); + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) local7); + long[] callResult_24 = instance.getMachine().call(1776, callArgs_24); + local5 = ((int) callResult_24[0]); + memory.writeI32((int) (local4 + 48) < 0 ? (local4 + 48) : (local4 + 48) + 0, (int) (local7 | -2147483648)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 40, (int) local5); + memory.writeI32((int) (local4 + 44) < 0 ? (local4 + 44) : (local4 + 44) + 0, (int) local3); + } + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) local3); + callArgs_25[1] = ((long) local6); + callArgs_25[0] = ((long) local5); + long[] callResult_25 = instance.getMachine().call(1891, callArgs_25); + memory.writeByte((int) (((int) callResult_25[0]) + local3) < 0 ? (((int) callResult_25[0]) + local3) : (((int) callResult_25[0]) + local3) + 0, (byte) (0)); + memory.writeI32((int) (local4 + 71) < 0 ? (local4 + 71) : (local4 + 71) + 0, (int) 0); + memory.writeLong((int) (local4 + 64) < 0 ? (local4 + 64) : (local4 + 64) + 0, (long) 0L); + local5 = (local4 + 56); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + local7 = (local4 + 80); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 65536); + local3 = 1; + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) local5); + callArgs_26[0] = ((long) arg0); + long[] callResult_26 = instance.getMachine().call(1200, callArgs_26); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_26[0])) != 0) { + break label_7; + } + label_16: { + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) 0); + callArgs_27[0] = ((long) arg0); + long[] callResult_27 = instance.getMachine().call(1154, callArgs_27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_27[0])) != 0) { + break label_16; + } + local3 = 1; + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) 1); + callArgs_28[0] = ((long) arg0); + long[] callResult_28 = instance.getMachine().call(1154, callArgs_28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(38, ((int) callResult_28[0])) != 0) { + break label_16; + } + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) local7); + callArgs_29[0] = ((long) arg0); + long[] callResult_29 = instance.getMachine().call(1203, callArgs_29); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_29[0])) != 0) { + break label_7; + } + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) 13); + callArgs_30[0] = ((long) arg0); + long[] callResult_30 = instance.getMachine().call(1155, callArgs_30); + if (((int) callResult_30[0]) != 0) { + break label_16; + } + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) arg0); + instance.getMachine().call(1217, callArgs_31); + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) 7027); + callArgs_32[0] = ((long) (local2 + 16)); + long[] callResult_32 = instance.getMachine().call(1167, callArgs_32); + local5 = ((int) callResult_32[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 44, (int) 1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) local5); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 40)); + long[] callArgs_33 = new long[2]; + callArgs_33[1] = ((long) (local2 + 8)); + callArgs_33[0] = ((long) (local2 + 104)); + long[] callResult_33 = instance.getMachine().call(1168, callArgs_33); + arg1 = ((int) callResult_33[0]); + long[] callArgs_34 = new long[3]; + callArgs_34[2] = ((long) 0); + callArgs_34[1] = ((long) arg1); + callArgs_34[0] = ((long) arg0); + long[] callResult_34 = instance.getMachine().call(1163, callArgs_34); + local3 = ((int) callResult_34[0]); + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) arg1); + long[] callResult_35 = instance.getMachine().call(1169, callArgs_35); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 11), -1) != 0) { + break label_7; + } + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + instance.getMachine().call(1777, callArgs_36); + break label_7; + } + label_17: { + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) 13); + callArgs_37[0] = ((long) arg0); + long[] callResult_37 = instance.getMachine().call(1159, callArgs_37); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_37[0])) != 0) { + break label_17; + } + long[] callArgs_38 = new long[1]; + callArgs_38[0] = ((long) (local2 + 80)); + long[] callResult_38 = instance.getMachine().call(1250, callArgs_38); + local6 = ((int) callResult_38[0]); + local3 = memory.readInt((int) (arg1 + 164) < 0 ? (arg1 + 164) : (arg1 + 164) + 0); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 160); + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) arg0); + callArgs_39[0] = ((long) (local2 + 16)); + instance.getMachine().call(1153, callArgs_39); + long[] callArgs_40 = new long[3]; + callArgs_40[2] = ((long) (local2 + 16)); + callArgs_40[1] = ((long) ((local3 - local5) >> 2)); + callArgs_40[0] = ((long) (local2 + 104)); + long[] callResult_40 = instance.getMachine().call(155, callArgs_40); + local3 = ((int) callResult_40[0]); + long[] callArgs_41 = new long[2]; + callArgs_41[1] = ((long) local3); + callArgs_41[0] = ((long) (local6 + 52)); + long[] callResult_41 = instance.getMachine().call(158, callArgs_41); + long[] callArgs_42 = new long[1]; + callArgs_42[0] = ((long) local3); + long[] callResult_42 = instance.getMachine().call(162, callArgs_42); + local3 = ((local2 + 104) + 8); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + local8 = ((local2 + 104) + 16); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 104, (long) 0L); + local9 = ((int) memory.read((int) (local4 + 74) < 0 ? (local4 + 74) : (local4 + 74) + 0) & 0xFF); + long[] callArgs_43 = new long[1]; + callArgs_43[0] = ((long) 104); + long[] callResult_43 = instance.getMachine().call(1776, callArgs_43); + local5 = ((int) callResult_43[0]); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 4, (long) 0L); + memory.writeI32((int) (local5 + 52) < 0 ? (local5 + 52) : (local5 + 52) + 0, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeLong((int) (local5 + 44) < 0 ? (local5 + 44) : (local5 + 44) + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 36, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeI32((int) (local5 + 88) < 0 ? (local5 + 88) : (local5 + 88) + 0, (int) 0); + memory.writeLong((int) (local5 + 72) < 0 ? (local5 + 72) : (local5 + 72) + 0, (long) 0L); + memory.writeLong((int) (local5 + 56) < 0 ? (local5 + 56) : (local5 + 56) + 0, (long) (local9 != 0 ? -2L : -1L)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 32, (int) 17); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 48964); + label_18: { + label_19: { + local3 = memory.readInt((int) (local6 + 92) < 0 ? (local6 + 92) : (local6 + 92) + 0); + if (local3 != 0) { + break label_19; + } + local3 = (local6 + 88); + break label_18; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local3); + local3 = (local3 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local5); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 92, (int) local5); + local3 = 1; + local8 = (local6 + 96); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 1)); + memory.writeI32((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (int) memory.readInt((int) ((local2 + 80) + 16) < 0 ? ((local2 + 80) + 16) : ((local2 + 80) + 16) + 0)); + memory.writeLong((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0, (long) memory.readLong((int) ((local2 + 80) + 8) < 0 ? ((local2 + 80) + 8) : ((local2 + 80) + 8) + 0)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 80)); + long[] callArgs_44 = new long[2]; + callArgs_44[1] = ((long) (local6 + 100)); + callArgs_44[0] = ((long) arg0); + long[] callResult_44 = instance.getMachine().call(1183, callArgs_44); + long[] callArgs_45 = new long[2]; + callArgs_45[1] = ((long) 44); + callArgs_45[0] = ((long) arg0); + long[] callResult_45 = instance.getMachine().call(1160, callArgs_45); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_45[0])) != 0) { + break label_8; + } + local3 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local3)) != 0) { + break label_1; + } + memory.writeByte((int) (local4 + 72) < 0 ? (local4 + 72) : (local4 + 72) + 0, (byte) (1)); + local5 = (memory.readInt((int) (local6 + 104) < 0 ? (local6 + 104) : (local6 + 104) + 0) - memory.readInt((int) local6 < 0 ? local6 : local6 + 100)); + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local5, local3)); + local10 = ((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local5), (local10 * com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3)))) + local10) & 4294967295L); + memory.writeLong((int) (local4 + 64) < 0 ? (local4 + 64) : (local4 + 64) + 0, (long) local10); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 56, (long) local10); + long[] callArgs_46 = new long[2]; + callArgs_46[1] = ((long) local4); + callArgs_46[0] = ((long) arg1); + instance.getMachine().call(147, callArgs_46); + long[] callArgs_47 = new long[2]; + callArgs_47[1] = ((long) local6); + callArgs_47[0] = ((long) arg1); + instance.getMachine().call(136, callArgs_47); + break label_9; + } + local3 = 1; + long[] callArgs_48 = new long[2]; + callArgs_48[1] = ((long) local5); + callArgs_48[0] = ((long) arg0); + long[] callResult_48 = instance.getMachine().call(1201, callArgs_48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_48[0])) != 0) { + break label_7; + } + local3 = 1; + long[] callArgs_49 = new long[2]; + callArgs_49[1] = ((long) local7); + callArgs_49[0] = ((long) arg0); + long[] callResult_49 = instance.getMachine().call(1203, callArgs_49); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_49[0])) != 0) { + break label_7; + } + long[] callArgs_50 = new long[2]; + callArgs_50[1] = ((long) local4); + callArgs_50[0] = ((long) arg1); + instance.getMachine().call(147, callArgs_50); + } + long[] callArgs_51 = new long[3]; + callArgs_51[2] = ((long) (((memory.readInt((int) (arg1 + 164) < 0 ? (arg1 + 164) : (arg1 + 164) + 0) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 160)) >> 2) + -1)); + callArgs_51[1] = ((long) (local2 + 48)); + callArgs_51[0] = ((long) arg1); + instance.getMachine().call(1234, callArgs_51); + long[] callArgs_52 = new long[2]; + callArgs_52[1] = ((long) 44); + callArgs_52[0] = ((long) arg0); + long[] callResult_52 = instance.getMachine().call(1160, callArgs_52); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_52[0])); + break label_6; + } + int ciTableIdx_53 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 4)); + int ciFuncId_53 = instance.table(0).requiredRef(ciTableIdx_53); + com.dylibso.chicory.runtime.Instance ciRefInstance_53 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_53), instance); + if (!ciRefInstance_53.type(ciRefInstance_53.functionType(ciFuncId_53)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_53 = new long[1]; + callArgs_53[0] = ((long) local6); + ciRefInstance_53.getMachine().call(ciFuncId_53, callArgs_53); + } + int ciTableIdx_54 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_54 = instance.table(0).requiredRef(ciTableIdx_54); + com.dylibso.chicory.runtime.Instance ciRefInstance_54 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_54), instance); + if (!ciRefInstance_54.type(ciRefInstance_54.functionType(ciFuncId_54)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_54 = new long[1]; + callArgs_54[0] = ((long) local4); + ciRefInstance_54.getMachine().call(ciFuncId_54, callArgs_54); + } + label_20: { + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_20; + } + label_21: while (true) { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + int ciTableIdx_55 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_55 = instance.table(0).requiredRef(ciTableIdx_55); + com.dylibso.chicory.runtime.Instance ciRefInstance_55 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_55), instance); + if (!ciRefInstance_55.type(ciRefInstance_55.functionType(ciFuncId_55)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_55 = new long[1]; + callArgs_55[0] = ((long) arg0); + ciRefInstance_55.getMachine().call(ciFuncId_55, callArgs_55); + arg0 = local4; + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_21; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 75), -1) != 0) { + break label_3; + } + long[] callArgs_56 = new long[1]; + callArgs_56[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 64)); + instance.getMachine().call(1777, callArgs_56); + } + instance.global(0).setValue(((long) (local2 + 144))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1227(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1227(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1228(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_2; + } + label_3: { + local4 = (arg0 + 16); + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 88)); + instance.getMachine().call(557, callArgs_1); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 88) + 8) < 0 ? ((local2 + 88) + 8) : ((local2 + 88) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 88) + 16) < 0 ? ((local2 + 88) + 16) : ((local2 + 88) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 88) + 24) < 0 ? ((local2 + 88) + 24) : ((local2 + 88) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 88) + 32) < 0 ? ((local2 + 88) + 32) : ((local2 + 88) + 32) + 0)); + label_4: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_4; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local3 * 40)) < 0 ? (local4 + (local3 * 40)) : (local4 + (local3 * 40)) + 36) & 0xFF) != 0) { + break label_3; + } + local3 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + } + local3 = (local4 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + local4 = (local3 + 8); + memory.writeLong((int) ((local2 + 64) + 8) < 0 ? ((local2 + 64) + 8) : ((local2 + 64) + 8) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + local5 = (local3 + 16); + memory.writeI32((int) ((local2 + 64) + 16) < 0 ? ((local2 + 64) + 16) : ((local2 + 64) + 16) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 64, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 184), memory.readInt((int) (arg1 + 188) < 0 ? (arg1 + 188) : (arg1 + 188) + 0)) != 0) { + break label_5; + } + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) 0); + callArgs_2[2] = ((long) 7936); + callArgs_2[1] = ((long) local2); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_2); + local3 = 1; + break label_2; + } + local3 = 1; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 46); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1160, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_2; + } + local3 = 1; + label_6: { + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) (local2 + 24)); + long[] callResult_4 = instance.getMachine().call(154, callArgs_4); + local4 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1166, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_6; + } + local3 = 1; + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 44); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1160, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_6[0])) != 0) { + break label_6; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) 72); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + arg0 = ((int) callResult_7[0]); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local4); + callArgs_8[0] = ((long) (local2 + 88)); + long[] callResult_8 = instance.getMachine().call(159, callArgs_8); + local3 = ((int) callResult_8[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51452); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) (local2 + 72) < 0 ? (local2 + 72) : (local2 + 72) + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0)); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local3); + callArgs_9[0] = ((long) (arg0 + 36)); + long[] callResult_9 = instance.getMachine().call(159, callArgs_9); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local3); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) arg0); + callArgs_11[0] = ((long) arg1); + instance.getMachine().call(148, callArgs_11); + local3 = 0; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local4); + long[] callResult_12 = instance.getMachine().call(162, callArgs_12); + } + instance.global(0).setValue(((long) (local2 + 128))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1228(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1228(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1229(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + local2 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_3; + } + label_4: { + local3 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 88)); + instance.getMachine().call(557, callArgs_1); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 88) + 8) < 0 ? ((local2 + 88) + 8) : ((local2 + 88) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 88) + 16) < 0 ? ((local2 + 88) + 16) : ((local2 + 88) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 88) + 24) < 0 ? ((local2 + 88) + 24) : ((local2 + 88) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 88) + 32) < 0 ? ((local2 + 88) + 32) : ((local2 + 88) + 32) + 0)); + label_5: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_5; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + local4 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_2; + } + memory.writeLong((int) ((local2 + 64) + 8) < 0 ? ((local2 + 64) + 8) : ((local2 + 64) + 8) + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeI32((int) ((local2 + 64) + 16) < 0 ? ((local2 + 64) + 16) : ((local2 + 64) + 16) + 0, (int) memory.readInt((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 64, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + local3 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 48); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1160, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_3; + } + memory.writeI32((int) ((local2 + 48) + 8) < 0 ? ((local2 + 48) + 8) : ((local2 + 48) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) 0L); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + 48)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1165, callArgs_3); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) 0L); + local3 = 1; + label_6: { + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 1); + callArgs_4[1] = ((long) (local2 + 32)); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1230, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_6; + } + label_7: { + label_8: { + label_9: { + label_10: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 0); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_5[0])) != 0) { + break label_10; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(26, ((int) callResult_6[0])) != 0) { + break label_10; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg1); + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(1231, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) 80); + long[] callResult_8 = instance.getMachine().call(1776, callArgs_8); + local4 = ((int) callResult_8[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) 1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 51116); + memory.writeLong((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (long) 0L); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) 0L); + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 59) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local3 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 52) : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + local6 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 48) : (local2 + 48)); + label_11: { + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_12; + } + local5 = (local4 + 32); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 43, (byte) (local3)); + break label_11; + } + local7 = ((local3 | 15) + 1); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local7); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + local5 = ((int) callResult_9[0]); + memory.writeI32((int) (local4 + 40) < 0 ? (local4 + 40) : (local4 + 40) + 0, (int) (local7 | -2147483648)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) local5); + memory.writeI32((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0, (int) local3); + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) local3); + callArgs_10[1] = ((long) local6); + callArgs_10[0] = ((long) local5); + long[] callResult_10 = instance.getMachine().call(1891, callArgs_10); + memory.writeByte((int) (((int) callResult_10[0]) + local3) < 0 ? (((int) callResult_10[0]) + local3) : (((int) callResult_10[0]) + local3) + 0, (byte) (0)); + memory.writeI32((int) (local4 + 63) < 0 ? (local4 + 63) : (local4 + 63) + 0, (int) 0); + memory.writeLong((int) (local4 + 56) < 0 ? (local4 + 56) : (local4 + 56) + 0, (long) 0L); + local5 = (local4 + 48); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + local6 = (local4 + 72); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) -16L); + local3 = 1; + label_13: { + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) 30); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1160, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + break label_13; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) 26); + callArgs_12[0] = ((long) arg0); + long[] callResult_12 = instance.getMachine().call(1160, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) != 0) { + break label_13; + } + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) 1); + callArgs_13[1] = ((long) (local4 + 4)); + callArgs_13[0] = ((long) arg0); + long[] callResult_13 = instance.getMachine().call(1196, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_13[0])) != 0) { + break label_13; + } + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) 1); + callArgs_14[1] = ((long) (local4 + 16)); + callArgs_14[0] = ((long) arg0); + long[] callResult_14 = instance.getMachine().call(1196, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])) != 0) { + break label_13; + } + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) 44); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1160, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_15[0])) != 0) { + break label_13; + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) local5); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1200, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_16[0])) != 0) { + break label_13; + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) local5); + callArgs_17[0] = ((long) arg0); + long[] callResult_17 = instance.getMachine().call(1201, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_17[0])) != 0) { + break label_13; + } + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) local6); + callArgs_18[0] = ((long) arg0); + long[] callResult_18 = instance.getMachine().call(1195, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_18[0])) != 0) { + break label_13; + } + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) arg0); + callArgs_19[0] = ((long) (local2 + 88)); + instance.getMachine().call(1153, callArgs_19); + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) 40); + long[] callResult_20 = instance.getMachine().call(1776, callArgs_20); + local3 = ((int) callResult_20[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 50208); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) memory.readLong((int) (local2 + 96) < 0 ? (local2 + 96) : (local2 + 96) + 0)); + memory.writeI32((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (int) memory.readInt((int) (local2 + 104) < 0 ? (local2 + 104) : (local2 + 104) + 0)); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) local3); + callArgs_21[0] = ((long) arg1); + instance.getMachine().call(145, callArgs_21); + break label_9; + } + int ciTableIdx_22 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_22 = instance.table(0).requiredRef(ciTableIdx_22); + com.dylibso.chicory.runtime.Instance ciRefInstance_22 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_22), instance); + if (!ciRefInstance_22.type(ciRefInstance_22.functionType(ciFuncId_22)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) local4); + ciRefInstance_22.getMachine().call(ciFuncId_22, callArgs_22); + break label_6; + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) 88); + long[] callResult_23 = instance.getMachine().call(1776, callArgs_23); + local4 = ((int) callResult_23[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 5); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 51572); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (local2 + 72) < 0 ? (local2 + 72) : (local2 + 72) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (local2 + 80) < 0 ? (local2 + 80) : (local2 + 80) + 0)); + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 59) & 0xFF); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3), 0); + local3 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 52) : local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 2147483632) != 0) { + break label_1; + } + local6 = (local5 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 48) : (local2 + 48)); + label_14: { + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 10) != 0) { + break label_15; + } + local5 = (local4 + 40); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 51, (byte) (local3)); + break label_14; + } + local7 = ((local3 | 15) + 1); + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) local7); + long[] callResult_24 = instance.getMachine().call(1776, callArgs_24); + local5 = ((int) callResult_24[0]); + memory.writeI32((int) (local4 + 48) < 0 ? (local4 + 48) : (local4 + 48) + 0, (int) (local7 | -2147483648)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 40, (int) local5); + memory.writeI32((int) (local4 + 44) < 0 ? (local4 + 44) : (local4 + 44) + 0, (int) local3); + } + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) local3); + callArgs_25[1] = ((long) local6); + callArgs_25[0] = ((long) local5); + long[] callResult_25 = instance.getMachine().call(1891, callArgs_25); + memory.writeByte((int) (((int) callResult_25[0]) + local3) < 0 ? (((int) callResult_25[0]) + local3) : (((int) callResult_25[0]) + local3) + 0, (byte) (0)); + memory.writeI32((int) (local4 + 71) < 0 ? (local4 + 71) : (local4 + 71) + 0, (int) 0); + memory.writeLong((int) (local4 + 64) < 0 ? (local4 + 64) : (local4 + 64) + 0, (long) 0L); + local3 = (local4 + 56); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) 0L); + local5 = (local4 + 80); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) -16L); + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) local3); + callArgs_26[0] = ((long) arg0); + long[] callResult_26 = instance.getMachine().call(1200, callArgs_26); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_26[0])) != 0) { + break label_7; + } + label_16: { + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) 0); + callArgs_27[0] = ((long) arg0); + long[] callResult_27 = instance.getMachine().call(1154, callArgs_27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(137, ((int) callResult_27[0])) != 0) { + break label_16; + } + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) (local2 + 24)); + callArgs_28[0] = ((long) arg0); + long[] callResult_28 = instance.getMachine().call(1195, callArgs_28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_28[0])) != 0) { + break label_7; + } + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) 30); + callArgs_29[0] = ((long) arg0); + long[] callResult_29 = instance.getMachine().call(1160, callArgs_29); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_29[0])) != 0) { + break label_7; + } + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) 18); + callArgs_30[0] = ((long) arg0); + long[] callResult_30 = instance.getMachine().call(1160, callArgs_30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_30[0])) != 0) { + break label_7; + } + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) (local2 + 64)); + long[] callResult_31 = instance.getMachine().call(1251, callArgs_31); + local6 = ((int) callResult_31[0]); + local3 = memory.readInt((int) (arg1 + 140) < 0 ? (arg1 + 140) : (arg1 + 140) + 0); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 136); + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) arg0); + callArgs_32[0] = ((long) local2); + instance.getMachine().call(1153, callArgs_32); + long[] callArgs_33 = new long[3]; + callArgs_33[2] = ((long) local2); + callArgs_33[1] = ((long) ((local3 - local5) >> 2)); + callArgs_33[0] = ((long) (local2 + 88)); + long[] callResult_33 = instance.getMachine().call(155, callArgs_33); + local3 = ((int) callResult_33[0]); + long[] callArgs_34 = new long[2]; + callArgs_34[1] = ((long) local3); + callArgs_34[0] = ((long) (local6 + 52)); + long[] callResult_34 = instance.getMachine().call(158, callArgs_34); + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) local3); + long[] callResult_35 = instance.getMachine().call(162, callArgs_35); + local5 = ((local2 + 88) + 8); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) 0L); + local7 = ((local2 + 88) + 16); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 88, (long) 0L); + local8 = ((int) memory.read((int) (local4 + 74) < 0 ? (local4 + 74) : (local4 + 74) + 0) & 0xFF); + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) 104); + long[] callResult_36 = instance.getMachine().call(1776, callArgs_36); + local3 = ((int) callResult_36[0]); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 4, (long) 0L); + memory.writeI32((int) (local3 + 52) < 0 ? (local3 + 52) : (local3 + 52) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) (local3 + 44) < 0 ? (local3 + 44) : (local3 + 44) + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 36, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeI32((int) (local3 + 88) < 0 ? (local3 + 88) : (local3 + 88) + 0, (int) 0); + memory.writeLong((int) (local3 + 72) < 0 ? (local3 + 72) : (local3 + 72) + 0, (long) 0L); + memory.writeLong((int) (local3 + 56) < 0 ? (local3 + 56) : (local3 + 56) + 0, (long) (local8 != 0 ? -2L : -1L)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) 17); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 48964); + label_17: { + label_18: { + local5 = memory.readInt((int) (local6 + 100) < 0 ? (local6 + 100) : (local6 + 100) + 0); + if (local5 != 0) { + break label_18; + } + local5 = (local6 + 96); + break label_17; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local5); + local5 = (local5 + 4); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 100, (int) local3); + local5 = (local6 + 104); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) (memory.readInt((int) local5 < 0 ? local5 : local5 + 0) + 1)); + memory.writeI32((int) (local3 + 28) < 0 ? (local3 + 28) : (local3 + 28) + 0, (int) memory.readInt((int) ((local2 + 64) + 16) < 0 ? ((local2 + 64) + 16) : ((local2 + 64) + 16) + 0)); + memory.writeLong((int) (local3 + 20) < 0 ? (local3 + 20) : (local3 + 20) + 0, (long) memory.readLong((int) ((local2 + 64) + 8) < 0 ? ((local2 + 64) + 8) : ((local2 + 64) + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 64)); + local9 = memory.readLong((int) local2 < 0 ? local2 : local2 + 24); + memory.writeLong((int) (local6 + 88) < 0 ? (local6 + 88) : (local6 + 88) + 0, (long) local9); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + local3 = (local6 + 108); + label_19: { + label_20: { + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) local2); + callArgs_37[0] = ((long) arg0); + long[] callResult_37 = instance.getMachine().call(1186, callArgs_37); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_37[0])) != 0) { + break label_20; + } + long[] callArgs_38 = new long[2]; + callArgs_38[1] = ((long) local2); + callArgs_38[0] = ((long) local3); + instance.getMachine().call(1189, callArgs_38); + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) local3); + callArgs_39[0] = ((long) arg0); + long[] callResult_39 = instance.getMachine().call(1187, callArgs_39); + break label_19; + } + long[] callArgs_40 = new long[2]; + callArgs_40[1] = ((long) local3); + callArgs_40[0] = ((long) arg0); + long[] callResult_40 = instance.getMachine().call(1190, callArgs_40); + } + label_21: { + long[] callArgs_41 = new long[2]; + callArgs_41[1] = ((long) 44); + callArgs_41[0] = ((long) arg0); + long[] callResult_41 = instance.getMachine().call(1160, callArgs_41); + local7 = ((int) callResult_41[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7) != 0) { + break label_21; + } + memory.writeByte((int) (local4 + 72) < 0 ? (local4 + 72) : (local4 + 72) + 0, (byte) (1)); + local3 = memory.readInt((int) (local6 + 108) < 0 ? (local6 + 108) : (local6 + 108) + 0); + local5 = memory.readInt((int) (local6 + 112) < 0 ? (local6 + 112) : (local6 + 112) + 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 80, (long) local9); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local5 - local3), 12)); + memory.writeLong((int) (local4 + 64) < 0 ? (local4 + 64) : (local4 + 64) + 0, (long) local9); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 56, (long) local9); + long[] callArgs_42 = new long[2]; + callArgs_42[1] = ((long) local4); + callArgs_42[0] = ((long) arg1); + instance.getMachine().call(149, callArgs_42); + long[] callArgs_43 = new long[2]; + callArgs_43[1] = ((long) local6); + callArgs_43[0] = ((long) arg1); + instance.getMachine().call(139, callArgs_43); + local6 = 0; + local4 = 0; + } + label_22: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_22; + } + label_23: while (true) { + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + int ciTableIdx_44 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_44 = instance.table(0).requiredRef(ciTableIdx_44); + com.dylibso.chicory.runtime.Instance ciRefInstance_44 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_44), instance); + if (!ciRefInstance_44.type(ciRefInstance_44.functionType(ciFuncId_44)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_44 = new long[1]; + callArgs_44[0] = ((long) local3); + ciRefInstance_44.getMachine().call(ciFuncId_44, callArgs_44); + local3 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break; + } + } + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_24; + } + int ciTableIdx_45 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 4)); + int ciFuncId_45 = instance.table(0).requiredRef(ciTableIdx_45); + com.dylibso.chicory.runtime.Instance ciRefInstance_45 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_45), instance); + if (!ciRefInstance_45.type(ciRefInstance_45.functionType(ciFuncId_45)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_45 = new long[1]; + callArgs_45[0] = ((long) local6); + ciRefInstance_45.getMachine().call(ciFuncId_45, callArgs_45); + } + local3 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local7) != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_9; + } + int ciTableIdx_46 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_46 = instance.table(0).requiredRef(ciTableIdx_46); + com.dylibso.chicory.runtime.Instance ciRefInstance_46 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_46), instance); + if (!ciRefInstance_46.type(ciRefInstance_46.functionType(ciFuncId_46)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_46 = new long[1]; + callArgs_46[0] = ((long) local4); + ciRefInstance_46.getMachine().call(ciFuncId_46, callArgs_46); + break label_9; + } + long[] callArgs_47 = new long[2]; + callArgs_47[1] = ((long) local3); + callArgs_47[0] = ((long) arg0); + long[] callResult_47 = instance.getMachine().call(1201, callArgs_47); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_47[0])) != 0) { + break label_7; + } + long[] callArgs_48 = new long[2]; + callArgs_48[1] = ((long) local5); + callArgs_48[0] = ((long) arg0); + long[] callResult_48 = instance.getMachine().call(1195, callArgs_48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_48[0])) != 0) { + break label_7; + } + long[] callArgs_49 = new long[2]; + callArgs_49[1] = ((long) local4); + callArgs_49[0] = ((long) arg1); + instance.getMachine().call(149, callArgs_49); + } + long[] callArgs_50 = new long[3]; + callArgs_50[2] = ((long) (((memory.readInt((int) (arg1 + 140) < 0 ? (arg1 + 140) : (arg1 + 140) + 0) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 136)) >> 2) + -1)); + callArgs_50[1] = ((long) (local2 + 32)); + callArgs_50[0] = ((long) arg1); + instance.getMachine().call(1234, callArgs_50); + long[] callArgs_51 = new long[2]; + callArgs_51[1] = ((long) 44); + callArgs_51[0] = ((long) arg0); + long[] callResult_51 = instance.getMachine().call(1160, callArgs_51); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_51[0])); + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_6; + } + } + int ciTableIdx_52 = (int) (memory.readInt((int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0) < 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 0) : memory.readInt((int) local4 < 0 ? local4 : local4 + 0) + 4)); + int ciFuncId_52 = instance.table(0).requiredRef(ciTableIdx_52); + com.dylibso.chicory.runtime.Instance ciRefInstance_52 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_52), instance); + if (!ciRefInstance_52.type(ciRefInstance_52.functionType(ciFuncId_52)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_52 = new long[1]; + callArgs_52[0] = ((long) local4); + ciRefInstance_52.getMachine().call(ciFuncId_52, callArgs_52); + local3 = 1; + } + label_25: { + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_25; + } + label_26: while (true) { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + int ciTableIdx_53 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_53 = instance.table(0).requiredRef(ciTableIdx_53); + com.dylibso.chicory.runtime.Instance ciRefInstance_53 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_53), instance); + if (!ciRefInstance_53.type(ciRefInstance_53.functionType(ciFuncId_53)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_53 = new long[1]; + callArgs_53[0] = ((long) arg0); + ciRefInstance_53.getMachine().call(ciFuncId_53, callArgs_53); + arg0 = local4; + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_26; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 59), -1) != 0) { + break label_3; + } + long[] callArgs_54 = new long[1]; + callArgs_54[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 48)); + instance.getMachine().call(1777, callArgs_54); + } + instance.global(0).setValue(((long) (local2 + 128))); + return local3; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1229(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1229(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1230(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 0; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_1; + } + local5 = (arg0 + 16); + label_2: { + label_3: while (true) { + label_4: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(21, ((int) callResult_1[0])) != 0) { + break label_4; + } + local4 = 0; + break label_1; + } + local4 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 30); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1160, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_1; + } + label_5: { + local6 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + if (((int) memory.read((int) (local5 + (local6 * 40)) < 0 ? (local5 + (local6 * 40)) : (local5 + (local6 * 40)) + 36) & 0xFF) != 0) { + break label_5; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_3[0] = ((long) (local3 + 8)); + instance.getMachine().call(557, callArgs_3); + local6 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local7 = (local5 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) * 40)); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 8)); + memory.writeLong((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0, (long) memory.readLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0)); + memory.writeLong((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (long) memory.readLong((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0)); + memory.writeLong((int) (local7 + 24) < 0 ? (local7 + 24) : (local7 + 24) + 0, (long) memory.readLong((int) ((local3 + 8) + 24) < 0 ? ((local3 + 8) + 24) : ((local3 + 8) + 24) + 0)); + memory.writeI32((int) (local7 + 32) < 0 ? (local7 + 32) : (local7 + 32) + 0, (int) memory.readInt((int) ((local3 + 8) + 32) < 0 ? ((local3 + 8) + 32) : ((local3 + 8) + 32) + 0)); + label_6: { + if (((int) memory.read((int) local7 < 0 ? local7 : local7 + 36) & 0xFF) != 0) { + break label_6; + } + memory.writeByte((int) local7 < 0 ? local7 : local7 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local5 + (local6 * 40)) < 0 ? (local5 + (local6 * 40)) : (local5 + (local6 * 40)) + 36) & 0xFF) != 0) { + break label_5; + } + local6 = (local6 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local6)); + } + label_7: { + local7 = (local5 + (local6 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local7 < 0 ? local7 : local7 + 36) & 0xFF)) != 0) { + break label_7; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 88); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local6 = ((int) callResult_4[0]); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 4, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) 3); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 36, (long) 0L); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) 50448); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 12, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0, (long) memory.readLong((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0)); + memory.writeI32((int) (local6 + 28) < 0 ? (local6 + 28) : (local6 + 28) + 0, (int) memory.readInt((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0)); + memory.writeI32((int) (local6 + 44) < 0 ? (local6 + 44) : (local6 + 44) + 0, (int) 0); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) (local6 + 52)); + long[] callResult_5 = instance.getMachine().call(154, callArgs_5); + memory.writeI32((int) (local6 + 48) < 0 ? (local6 + 48) : (local6 + 48) + 0, (int) arg2); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 21); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1160, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_6[0])) != 0) { + break label_2; + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 1); + callArgs_7[1] = ((long) (local6 + 36)); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1196, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_7[0])) != 0) { + break label_2; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) 44); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1160, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_8[0])) != 0) { + break label_2; + } + local7 = arg1; + label_8: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_8; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local4); + local7 = (local4 + 4); + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local6); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local6); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) + 1)); + local4 = 0; + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) 0); + callArgs_9[0] = ((long) arg0); + long[] callResult_9 = instance.getMachine().call(1154, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(30, ((int) callResult_9[0])) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break label_1; + } + break; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + int ciTableIdx_11 = (int) (memory.readInt((int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0) < 0 ? memory.readInt((int) local6 < 0 ? local6 : local6 + 0) : memory.readInt((int) local6 < 0 ? local6 : local6 + 0) + 4)); + int ciFuncId_11 = instance.table(0).requiredRef(ciTableIdx_11); + com.dylibso.chicory.runtime.Instance ciRefInstance_11 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_11), instance); + if (!ciRefInstance_11.type(ciRefInstance_11.functionType(ciFuncId_11)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local6); + ciRefInstance_11.getMachine().call(ciFuncId_11, callArgs_11); + } + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1230(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1230(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1231(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 48), ((memory.readInt((int) (arg1 + 80) < 0 ? (arg1 + 80) : (arg1 + 80) + 0) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 76)) >> 2)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 52), ((memory.readInt((int) (arg1 + 140) < 0 ? (arg1 + 140) : (arg1 + 140) + 0) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 136)) >> 2)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 56), ((memory.readInt((int) (arg1 + 164) < 0 ? (arg1 + 164) : (arg1 + 164) + 0) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 160)) >> 2)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 60), ((memory.readInt((int) (arg1 + 92) < 0 ? (arg1 + 92) : (arg1 + 92) + 0) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 88)) >> 2)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 44), ((memory.readInt((int) (arg1 + 68) < 0 ? (arg1 + 68) : (arg1 + 68) + 0) - memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 64)) >> 2)) != 0) { + break label_2; + } + } + label_4: { + local3 = (arg0 + 16); + arg1 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local3 + (arg1 * 40)) < 0 ? (local3 + (arg1 * 40)) : (local3 + (arg1 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_0[0] = ((long) (local2 + 24)); + instance.getMachine().call(557, callArgs_0); + arg1 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local4 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) * 40)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 24)); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) ((local2 + 24) + 8) < 0 ? ((local2 + 24) + 8) : ((local2 + 24) + 8) + 0)); + memory.writeLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (long) memory.readLong((int) ((local2 + 24) + 16) < 0 ? ((local2 + 24) + 16) : ((local2 + 24) + 16) + 0)); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) memory.readLong((int) ((local2 + 24) + 24) < 0 ? ((local2 + 24) + 24) : ((local2 + 24) + 24) + 0)); + memory.writeI32((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (int) memory.readInt((int) ((local2 + 24) + 32) < 0 ? ((local2 + 24) + 32) : ((local2 + 24) + 32) + 0)); + label_5: { + if (((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF) != 0) { + break label_5; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (arg1 * 40)) < 0 ? (local3 + (arg1 * 40)) : (local3 + (arg1 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + arg1 = (arg1 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (arg1)); + } + arg1 = (local3 + (arg1 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) 7869); + callArgs_1[1] = ((long) local2); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_1); + } + instance.global(0).setValue(((long) (local2 + 64))); + return; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1231(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1231(arg0, arg1, memory, instance); + return null; + } + + public static int func_1232(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_4; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(50, ((int) callResult_1[0])) != 0) { + break label_4; + } + local2 = (arg0 + 16); + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = (local2 + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local4 + 36) < 0 ? (local4 + 36) : (local4 + 36) + 0, (byte) (0)); + local4 = 1; + local5 = (local3 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + local2 = (local2 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local2 < 0 ? local2 : local2 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local3)); + memory.writeByte((int) (local2 + 36) < 0 ? (local2 + 36) : (local2 + 36) + 0, (byte) (0)); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (1)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 4)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1166, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_2; + } + local4 = 1; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 44); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1160, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_3[0])) != 0) { + break label_3; + } + break label_2; + } + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (0)); + } + local4 = 0; + } + return local4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1232(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1232(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1233(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = 1; + label_1: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (arg1 + 24)); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 39); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1238, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (arg1 + 44)); + callArgs_1[2] = ((long) (arg1 + 12)); + callArgs_1[1] = ((long) 43); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1238, callArgs_1); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])); + } + return local2; + } + + public static long[] call_1233(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1233(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1234(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 64); + instance.global(0).setValue(((long) local3)); + local4 = memory.readInt((int) (arg0 + 36) < 0 ? (arg0 + 36) : (arg0 + 36) + 0); + memory.writeLong((int) (local3 + 48) < 0 ? (local3 + 48) : (local3 + 48) + 0, (long) memory.readLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0)); + memory.writeI32((int) (local3 + 56) < 0 ? (local3 + 56) : (local3 + 56) + 0, (int) memory.readInt((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 12)); + label_1: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + label_2: while (true) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (local3 + 40)); + callArgs_0[1] = ((long) arg2); + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(155, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) (local4 + 52)); + long[] callResult_1 = instance.getMachine().call(158, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(151, callArgs_3); + instance.global(0).setValue(((long) (local3 + 64))); + return; + } + + public static long[] call_1234(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1234(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1235(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + local3 = 1; + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 30); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1160, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + local3 = 0; + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + local4 = ((int) callResult_1[0]); + switch((local4 + -20)) { + case 0: + { + break label_5; + } + case 1: + { + break label_2; + } + case 2: + { + break label_2; + } + case 3: + { + break label_2; + } + case 4: + { + break label_2; + } + case 5: + { + break label_6; + } + case 6: + { + break label_2; + } + case 7: + { + break label_2; + } + case 8: + { + break label_2; + } + case 9: + { + break label_2; + } + case 10: + { + break label_2; + } + case 11: + { + break label_7; + } + case 12: + { + break label_2; + } + case 13: + { + break label_2; + } + case 14: + { + break label_2; + } + case 15: + { + break label_2; + } + case 16: + { + break label_2; + } + case 17: + { + break label_2; + } + case 18: + { + break label_2; + } + case 19: + { + break label_2; + } + case 20: + { + break label_2; + } + case 21: + { + break label_2; + } + case 22: + { + break label_2; + } + case 23: + { + break label_2; + } + case 24: + { + break label_2; + } + case 25: + { + break label_2; + } + case 26: + { + break label_2; + } + case 27: + { + break label_2; + } + case 28: + { + break label_8; + } + default: + { + break label_4; + } + } + } + local3 = 1; + break label_3; + } + local3 = 2; + break label_3; + } + local3 = 3; + break label_3; + } + local3 = 4; + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(138, local4) != 0) { + break label_2; + } + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 12, (int) local3); + label_9: { + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local3 = ((arg0 + (local4 * 40)) + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF)) != 0) { + break label_9; + } + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (0)); + local3 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 16)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1166, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_1; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 44); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1160, callArgs_3); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])); + break label_1; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 32); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + local4 = ((int) callResult_5[0]); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 16, (byte) (0)); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 17685)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 17677)); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) 12); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + arg1 = ((int) callResult_6[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + local3 = (arg1 + 12); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local3); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 16); + callArgs_7[1] = ((long) local4); + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(1647, callArgs_7); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) local3); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 0); + callArgs_8[1] = ((long) local2); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1163, callArgs_8); + local3 = ((int) callResult_8[0]); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_10; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_10); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_11); + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_1235(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1235(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1236(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + local3 = 1; + label_1: { + long[] callArgs_0 = new long[6]; + callArgs_0[5] = ((long) 0); + callArgs_0[4] = ((long) (arg1 + 24)); + callArgs_0[3] = ((long) arg2); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 39); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1237, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_1; + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (arg1 + 44)); + callArgs_1[2] = ((long) (arg1 + 12)); + callArgs_1[1] = ((long) 43); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1238, callArgs_1); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])); + } + return local3; + } + + public static long[] call_1236(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1236(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1237(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + local6 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local6)); + local7 = (arg0 + 16); + local8 = ((local6 + 32) + 24); + local9 = ((local6 + 72) + 8); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: while (true) { + label_6: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(30, ((int) callResult_0[0])) != 0) { + break label_6; + } + local10 = 0; + break label_4; + } + label_7: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, ((int) callResult_1[0])) != 0) { + break label_7; + } + local10 = 0; + break label_4; + } + local10 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local11 = (local7 + (local10 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local11 < 0 ? local11 : local11 + 36) & 0xFF)) != 0) { + break label_3; + } + memory.writeByte((int) (local11 + 36) < 0 ? (local11 + 36) : (local11 + 36) + 0, (byte) (0)); + local11 = (local10 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local11)); + local11 = (local7 + (local11 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local11 < 0 ? local11 : local11 + 36) & 0xFF)) != 0) { + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local10)); + memory.writeByte((int) (local11 + 36) < 0 ? (local11 + 36) : (local11 + 36) + 0, (byte) (0)); + label_8: { + label_9: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1154, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_2[0])) != 0) { + break label_9; + } + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) 0); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 72, (long) 0L); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (local6 + 32)); + long[] callResult_3 = instance.getMachine().call(154, callArgs_3); + local12 = ((int) callResult_3[0]); + label_10: { + local10 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + if (((int) memory.read((int) (local7 + (local10 * 40)) < 0 ? (local7 + (local10 * 40)) : (local7 + (local10 * 40)) + 36) & 0xFF) != 0) { + break label_10; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_4[0] = ((long) (local6 + 88)); + instance.getMachine().call(557, callArgs_4); + local10 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local11 = (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) * 40)); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 88)); + memory.writeLong((int) (local11 + 8) < 0 ? (local11 + 8) : (local11 + 8) + 0, (long) memory.readLong((int) ((local6 + 88) + 8) < 0 ? ((local6 + 88) + 8) : ((local6 + 88) + 8) + 0)); + memory.writeLong((int) (local11 + 16) < 0 ? (local11 + 16) : (local11 + 16) + 0, (long) memory.readLong((int) ((local6 + 88) + 16) < 0 ? ((local6 + 88) + 16) : ((local6 + 88) + 16) + 0)); + memory.writeLong((int) (local11 + 24) < 0 ? (local11 + 24) : (local11 + 24) + 0, (long) memory.readLong((int) ((local6 + 88) + 24) < 0 ? ((local6 + 88) + 24) : ((local6 + 88) + 24) + 0)); + memory.writeI32((int) (local11 + 32) < 0 ? (local11 + 32) : (local11 + 32) + 0, (int) memory.readInt((int) ((local6 + 88) + 32) < 0 ? ((local6 + 88) + 32) : ((local6 + 88) + 32) + 0)); + label_11: { + if (((int) memory.read((int) local11 < 0 ? local11 : local11 + 36) & 0xFF) != 0) { + break label_11; + } + memory.writeByte((int) local11 < 0 ? local11 : local11 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local7 + (local10 * 40)) < 0 ? (local7 + (local10 * 40)) : (local7 + (local10 * 40)) + 36) & 0xFF) != 0) { + break label_10; + } + local10 = (local10 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local10)); + } + local10 = (local7 + (local10 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local10 < 0 ? local10 : local10 + 36) & 0xFF)) != 0) { + break label_3; + } + local11 = ((local6 + 8) + 8); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) memory.readLong((int) (local10 + 8) < 0 ? (local10 + 8) : (local10 + 8) + 0)); + local13 = ((local6 + 8) + 16); + memory.writeI32((int) local13 < 0 ? local13 : local13 + 0, (int) memory.readInt((int) (local10 + 16) < 0 ? (local10 + 16) : (local10 + 16) + 0)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 8, (long) memory.readLong((int) local10 < 0 ? local10 : local10 + 0)); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) (local6 + 72)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1165, callArgs_5); + label_12: { + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local12); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1191, callArgs_6); + local14 = ((int) callResult_6[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local14) != 0) { + break label_12; + } + memory.writeLong((int) ((local6 + 88) + 8) < 0 ? ((local6 + 88) + 8) : ((local6 + 88) + 8) + 0, (long) memory.readLong((int) local11 < 0 ? local11 : local11 + 0)); + memory.writeI32((int) ((local6 + 88) + 16) < 0 ? ((local6 + 88) + 16) : ((local6 + 88) + 16) + 0, (int) memory.readInt((int) local13 < 0 ? local13 : local13 + 0)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 88, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 8)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 108, (int) (((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) - memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)) >> 3) + arg5)); + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) (local6 + 88)); + callArgs_7[2] = ((long) (local6 + 72)); + callArgs_7[1] = ((long) arg3); + callArgs_7[0] = ((long) (local6 + 128)); + instance.getMachine().call(137, callArgs_7); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 128)); + callArgs_8[0] = ((long) arg3); + long[] callResult_8 = instance.getMachine().call(138, callArgs_8); + label_13: { + if (memory.readInt((int) local6 < 0 ? local6 : local6 + 52) != 0) { + break label_13; + } + local15 = memory.readInt((int) local6 < 0 ? local6 : local6 + 56); + label_14: { + local10 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + local11 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local10, local11) != 0) { + break label_14; + } + memory.writeLong((int) local10 < 0 ? local10 : local10 + 0, (long) (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local15) | -4294967296L)); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) (local10 + 8)); + break label_12; + } + local13 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local16 = ((local10 - local13) >> 3); + local17 = (local16 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local17, 536870912) != 0) { + break label_2; + } + label_15: { + label_16: { + local11 = (local11 - local13); + local18 = (local11 >>> 2); + local17 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local11, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local18, local17) != 0 ? local18 : local17) : 536870911); + if (local17 != 0) { + break label_16; + } + local18 = 0; + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local17, 536870912) != 0) { + break label_1; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) (local17 << 3)); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + local18 = ((int) callResult_9[0]); + } + local11 = (local18 + (local16 << 3)); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local15) | -4294967296L)); + local15 = (local18 + (local17 << 3)); + local17 = (local11 + 8); + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local13, local10) != 0) { + break label_17; + } + label_18: while (true) { + local11 = (local11 + -8); + local10 = (local10 + -8); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) memory.readLong((int) local10 < 0 ? local10 : local10 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local13, local10) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + local10 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) local15); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) local17); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_12; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local10); + instance.getMachine().call(1777, callArgs_10); + break label_12; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 128, (int) (((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) - memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)) >> 3) + arg5)); + long[] callArgs_11 = new long[4]; + callArgs_11[3] = ((long) local8); + callArgs_11[2] = ((long) (local6 + 128)); + callArgs_11[1] = ((long) arg4); + callArgs_11[0] = ((long) (local6 + 88)); + instance.getMachine().call(1193, callArgs_11); + label_19: { + local10 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4); + local11 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local10, local11) != 0) { + break label_19; + } + memory.writeLong((int) local10 < 0 ? local10 : local10 + 0, (long) -21L); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) (local10 + 8)); + break label_12; + } + local13 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + local18 = ((local10 - local13) >> 3); + local15 = (local18 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local15, 536870912) != 0) { + break label_2; + } + label_20: { + label_21: { + local11 = (local11 - local13); + local17 = (local11 >>> 2); + local15 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local11, 2147483640) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local17, local15) != 0 ? local17 : local15) : 536870911); + if (local15 != 0) { + break label_21; + } + local17 = 0; + break label_20; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local15, 536870912) != 0) { + break label_1; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) (local15 << 3)); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + local17 = ((int) callResult_12[0]); + } + local11 = (local17 + (local18 << 3)); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) -21L); + local15 = (local17 + (local15 << 3)); + local17 = (local11 + 8); + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local13, local10) != 0) { + break label_22; + } + label_23: while (true) { + local11 = (local11 + -8); + local10 = (local10 + -8); + memory.writeLong((int) local11 < 0 ? local11 : local11 + 0, (long) memory.readLong((int) local10 < 0 ? local10 : local10 + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local13, local10) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break; + } + local10 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 8, (int) local15); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 4, (int) local17); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_12; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local10); + instance.getMachine().call(1777, callArgs_13); + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local12); + long[] callResult_14 = instance.getMachine().call(162, callArgs_14); + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local6 < 0 ? local6 : local6 + 83), -1) != 0) { + break label_24; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 72)); + instance.getMachine().call(1777, callArgs_15); + } + local10 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local14) != 0) { + break label_8; + } + break label_4; + } + local10 = 1; + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) arg4); + callArgs_16[1] = ((long) arg2); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1192, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_16[0])) != 0) { + break label_4; + } + } + local10 = 1; + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) 44); + callArgs_17[0] = ((long) arg0); + long[] callResult_17 = instance.getMachine().call(1160, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_17[0])) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + instance.global(0).setValue(((long) (local6 + 144))); + return local10; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1237(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int result = Wat2WasmMachine.func_1237(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1238(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (arg0 + 16); + label_1: { + label_2: while (true) { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(30, ((int) callResult_0[0])) != 0) { + break label_3; + } + return 0; + } + label_4: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, ((int) callResult_1[0])) != 0) { + break label_4; + } + return 0; + } + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local6 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local6 + 36) < 0 ? (local6 + 36) : (local6 + 36) + 0, (byte) (0)); + local6 = (local5 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local6)); + local6 = (local4 + (local6 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + memory.writeByte((int) (local6 + 36) < 0 ? (local6 + 36) : (local6 + 36) + 0, (byte) (0)); + local5 = 1; + label_5: { + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg3); + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1192, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_5; + } + local5 = 1; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 44); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1160, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_3[0])) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + } + break; + } + return local5; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1238(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1238(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1239(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_1); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 0); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_4; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_2); + } + return arg0; + } + + public static long[] call_1239(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1239(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1240(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + local3 = (local2 + 20); + local4 = ((local2 + 8) + 8); + label_1: { + label_2: while (true) { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(137, ((int) callResult_0[0])) != 0) { + break label_3; + } + local5 = 0; + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_1[0])) != 0) { + break label_1; + } + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) -274877906944L); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) 0L); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 28, (byte) (0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) -1); + label_4: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 8)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1242, callArgs_2); + local6 = ((int) callResult_2[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6) != 0) { + break label_4; + } + label_5: { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8), local5) != 0) { + break label_5; + } + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 19), 0) != 0) { + break label_7; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + break label_6; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 12)); + callArgs_3[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + callArgs_3[0] = ((long) local5); + instance.getMachine().call(1647, callArgs_3); + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 12, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeByte((int) (local5 + 20) < 0 ? (local5 + 20) : (local5 + 20) + 0, (byte) (((int) memory.read((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0) & 0xFF))); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (local5 + 24)); + break label_4; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + 8)); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(1252, callArgs_4); + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 19), -1) != 0) { + break label_8; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + instance.getMachine().call(1777, callArgs_5); + } + local5 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + instance.global(0).setValue(((long) (local2 + 32))); + return local5; + } + + public static long[] call_1240(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1240(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1241(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 64); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 35, (byte) (0)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 36, (int) 2); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 40, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 50840); + memory.writeLong((int) (local1 + 12) < 0 ? (local1 + 12) : (local1 + 12) + 0, (long) 0L); + memory.writeLong((int) (local1 + 17) < 0 ? (local1 + 17) : (local1 + 17) + 0, (long) 0L); + memory.writeI32((int) (local1 + 48) < 0 ? (local1 + 48) : (local1 + 48) + 0, (int) 0); + memory.writeByte((int) (local1 + 60) < 0 ? (local1 + 60) : (local1 + 60) + 0, (byte) (0)); + memory.writeLong((int) (local1 + 52) < 0 ? (local1 + 52) : (local1 + 52) + 0, (long) -64L); + return local1; + } + + public static long[] call_1241(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1241(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1242(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (local2 + 12)); + label_1: { + label_2: { + label_3: { + label_4: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_4; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(22, ((int) callResult_1[0])) != 0) { + break label_4; + } + local3 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + arg1 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (arg1 + 36) < 0 ? (arg1 + 36) : (arg1 + 36) + 0, (byte) (0)); + arg1 = 1; + local5 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + local3 = (local3 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 12)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1165, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + long[] callResult_3 = instance.getMachine().call(1253, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_2; + } + arg1 = 1; + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 44); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1160, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_4[0])) != 0) { + break label_3; + } + break label_2; + } + arg1 = 1; + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local2); + long[] callResult_5 = instance.getMachine().call(1253, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_2; + } + } + arg1 = 0; + } + instance.global(0).setValue(((long) (local2 + 16))); + return arg1; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1242(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1242(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1243(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(33, ((int) callResult_1[0])) != 0) { + break label_3; + } + local3 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local5 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local5 + 36) < 0 ? (local5 + 36) : (local5 + 36) + 0, (byte) (0)); + local5 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + local5 = (local3 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + memory.writeByte((int) (local5 + 36) < 0 ? (local5 + 36) : (local5 + 36) + 0, (byte) (0)); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 20, (byte) (1)); + label_4: { + label_5: { + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local2 + 72)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + local5 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1191, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_5; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 12, (long) (((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 24) & 0xFFFFFFFFL) | -4294967296L)); + arg1 = 0; + memory.writeByte((int) (local2 + 22) < 0 ? (local2 + 22) : (local2 + 22) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 27820) & 0xFF))); + memory.writeByte((int) (local2 + 34) < 0 ? (local2 + 34) : (local2 + 34) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 28188) & 0xFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 19, (byte) (3)); + memory.writeShort((int) local2 < 0 ? local2 : local2 + 8, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 28150) & 0xFFFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 10, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 28152) & 0xFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 31, (byte) (3)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 11, (byte) (0)); + memory.writeShort((int) local2 < 0 ? local2 : local2 + 20, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 27818) & 0xFFFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 43, (byte) (3)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 23, (byte) (0)); + memory.writeShort((int) local2 < 0 ? local2 : local2 + 32, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 28186) & 0xFFFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 55, (byte) (3)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 35, (byte) (0)); + memory.writeByte((int) (local2 + 46) < 0 ? (local2 + 46) : (local2 + 46) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 27855) & 0xFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 47, (byte) (0)); + memory.writeShort((int) local2 < 0 ? local2 : local2 + 44, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 27853) & 0xFFFF))); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 48); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local4 = ((int) callResult_4[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 8)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 20)); + memory.writeI32((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (int) memory.readInt((int) ((local2 + 8) + 20) < 0 ? ((local2 + 8) + 20) : ((local2 + 8) + 20) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 32)); + memory.writeI32((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (int) memory.readInt((int) ((local2 + 8) + 32) < 0 ? ((local2 + 8) + 32) : ((local2 + 8) + 32) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 36, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 44)); + memory.writeI32((int) (local4 + 44) < 0 ? (local4 + 44) : (local4 + 44) + 0, (int) memory.readInt((int) ((local2 + 8) + 44) < 0 ? ((local2 + 8) + 44) : ((local2 + 8) + 44) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 56, (int) local4); + local6 = (local4 + 48); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 64, (int) local6); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 60, (int) local6); + label_6: { + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 0); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_5[0])) != 0) { + break label_6; + } + arg1 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local3 = (local3 + (arg1 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((arg1 ^ 1))); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 0); + callArgs_6[1] = ((long) (local2 + 56)); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1163, callArgs_6); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_6[0])); + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 47), -1) != 0) { + break label_7; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 36)); + instance.getMachine().call(1777, callArgs_7); + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 35), -1) != 0) { + break label_8; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 24)); + instance.getMachine().call(1777, callArgs_8); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 23), -1) != 0) { + break label_9; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 12)); + instance.getMachine().call(1777, callArgs_9); + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 11), -1) != 0) { + break label_10; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + instance.getMachine().call(1777, callArgs_10); + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_11); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 55), -1) != 0) { + break label_11; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 44)); + instance.getMachine().call(1777, callArgs_12); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 43), -1) != 0) { + break label_12; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 32)); + instance.getMachine().call(1777, callArgs_13); + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 31), -1) != 0) { + break label_13; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 20)); + instance.getMachine().call(1777, callArgs_14); + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 19), -1) != 0) { + break label_14; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 8)); + instance.getMachine().call(1777, callArgs_15); + } + if (arg1 != 0) { + break label_5; + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) 44); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1160, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_16[0])) != 0) { + break label_4; + } + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local5); + long[] callResult_17 = instance.getMachine().call(162, callArgs_17); + local4 = 1; + break label_2; + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) local5); + long[] callResult_18 = instance.getMachine().call(162, callArgs_18); + local4 = 0; + break label_2; + } + local4 = 1; + label_15: { + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) (local2 + 8)); + long[] callResult_19 = instance.getMachine().call(154, callArgs_19); + local5 = ((int) callResult_19[0]); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) local5); + callArgs_20[0] = ((long) arg0); + long[] callResult_20 = instance.getMachine().call(1191, callArgs_20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_20[0])) != 0) { + break label_15; + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 12, (long) (((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 24) & 0xFFFFFFFFL) | -4294967296L)); + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) local5); + long[] callResult_21 = instance.getMachine().call(162, callArgs_21); + local4 = 0; + break label_2; + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) local5); + long[] callResult_22 = instance.getMachine().call(162, callArgs_22); + } + instance.global(0).setValue(((long) (local2 + 112))); + return local4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1243(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1243(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1244(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 216); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 50568); + memory.writeLong((int) (local1 + 12) < 0 ? (local1 + 12) : (local1 + 12) + 0, (long) 0L); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) 0L); + memory.writeI32((int) (local1 + 28) < 0 ? (local1 + 28) : (local1 + 28) + 0, (int) 0); + label_1: { + local2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11) & 0xFF); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0); + local2 = (local3 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 2147483632) != 0) { + break label_1; + } + local3 = (local3 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : arg0); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 10) != 0) { + break label_3; + } + arg0 = (local1 + 32); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 43, (byte) (local2)); + break label_2; + } + local4 = ((local2 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg0 = ((int) callResult_1[0]); + memory.writeI32((int) (local1 + 40) < 0 ? (local1 + 40) : (local1 + 40) + 0, (int) (local4 | -2147483648)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 32, (int) arg0); + memory.writeI32((int) (local1 + 36) < 0 ? (local1 + 36) : (local1 + 36) + 0, (int) local2); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local2) < 0 ? (((int) callResult_2[0]) + local2) : (((int) callResult_2[0]) + local2) + 0, (byte) (0)); + memory.writeByte((int) (local1 + 44) < 0 ? (local1 + 44) : (local1 + 44) + 0, (byte) (0)); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (local1 + 48)); + long[] callResult_3 = instance.getMachine().call(154, callArgs_3); + memory.writeLong((int) (local1 + 116) < 0 ? (local1 + 116) : (local1 + 116) + 0, (long) 0L); + memory.writeLong((int) (local1 + 108) < 0 ? (local1 + 108) : (local1 + 108) + 0, (long) 0L); + memory.writeLong((int) (local1 + 100) < 0 ? (local1 + 100) : (local1 + 100) + 0, (long) 0L); + memory.writeLong((int) (local1 + 92) < 0 ? (local1 + 92) : (local1 + 92) + 0, (long) 0L); + memory.writeLong((int) (local1 + 84) < 0 ? (local1 + 84) : (local1 + 84) + 0, (long) 0L); + memory.writeLong((int) (local1 + 128) < 0 ? (local1 + 128) : (local1 + 128) + 0, (long) 0L); + memory.writeI32((int) (local1 + 124) < 0 ? (local1 + 124) : (local1 + 124) + 0, (int) 1065353216); + memory.writeLong((int) (local1 + 136) < 0 ? (local1 + 136) : (local1 + 136) + 0, (long) 0L); + memory.writeLong((int) (local1 + 148) < 0 ? (local1 + 148) : (local1 + 148) + 0, (long) 0L); + memory.writeI32((int) (local1 + 144) < 0 ? (local1 + 144) : (local1 + 144) + 0, (int) 1065353216); + memory.writeLong((int) (local1 + 156) < 0 ? (local1 + 156) : (local1 + 156) + 0, (long) 0L); + memory.writeLong((int) (local1 + 164) < 0 ? (local1 + 164) : (local1 + 164) + 0, (long) 0L); + memory.writeLong((int) (local1 + 180) < 0 ? (local1 + 180) : (local1 + 180) + 0, (long) 0L); + memory.writeLong((int) (local1 + 172) < 0 ? (local1 + 172) : (local1 + 172) + 0, (long) 4575657221408423936L); + memory.writeLong((int) (local1 + 188) < 0 ? (local1 + 188) : (local1 + 188) + 0, (long) 0L); + memory.writeLong((int) (local1 + 196) < 0 ? (local1 + 196) : (local1 + 196) + 0, (long) 0L); + memory.writeLong((int) (local1 + 204) < 0 ? (local1 + 204) : (local1 + 204) + 0, (long) 0L); + memory.writeByte((int) (local1 + 212) < 0 ? (local1 + 212) : (local1 + 212) + 0, (byte) (0)); + return local1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1244(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1244(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1245(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 80); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 28, (int) 1); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 51116); + memory.writeLong((int) (local1 + 12) < 0 ? (local1 + 12) : (local1 + 12) + 0, (long) 0L); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) 0L); + label_1: { + local2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11) & 0xFF); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0); + local2 = (local3 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 2147483632) != 0) { + break label_1; + } + local3 = (local3 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : arg0); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 10) != 0) { + break label_3; + } + arg0 = (local1 + 32); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 43, (byte) (local2)); + break label_2; + } + local4 = ((local2 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg0 = ((int) callResult_1[0]); + memory.writeI32((int) (local1 + 40) < 0 ? (local1 + 40) : (local1 + 40) + 0, (int) (local4 | -2147483648)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 32, (int) arg0); + memory.writeI32((int) (local1 + 36) < 0 ? (local1 + 36) : (local1 + 36) + 0, (int) local2); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local2) < 0 ? (((int) callResult_2[0]) + local2) : (((int) callResult_2[0]) + local2) + 0, (byte) (0)); + memory.writeI32((int) (local1 + 63) < 0 ? (local1 + 63) : (local1 + 63) + 0, (int) 0); + memory.writeLong((int) (local1 + 56) < 0 ? (local1 + 56) : (local1 + 56) + 0, (long) 0L); + memory.writeLong((int) (local1 + 48) < 0 ? (local1 + 48) : (local1 + 48) + 0, (long) 0L); + memory.writeLong((int) (local1 + 72) < 0 ? (local1 + 72) : (local1 + 72) + 0, (long) -16L); + return local1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1245(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1245(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1246(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 80); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 28, (int) 2); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 51224); + memory.writeLong((int) (local1 + 12) < 0 ? (local1 + 12) : (local1 + 12) + 0, (long) 0L); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) 0L); + label_1: { + local2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11) & 0xFF); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0); + local2 = (local3 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 2147483632) != 0) { + break label_1; + } + local3 = (local3 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : arg0); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 10) != 0) { + break label_3; + } + arg0 = (local1 + 32); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 43, (byte) (local2)); + break label_2; + } + local4 = ((local2 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg0 = ((int) callResult_1[0]); + memory.writeI32((int) (local1 + 40) < 0 ? (local1 + 40) : (local1 + 40) + 0, (int) (local4 | -2147483648)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 32, (int) arg0); + memory.writeI32((int) (local1 + 36) < 0 ? (local1 + 36) : (local1 + 36) + 0, (int) local2); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local2) < 0 ? (((int) callResult_2[0]) + local2) : (((int) callResult_2[0]) + local2) + 0, (byte) (0)); + memory.writeI32((int) (local1 + 63) < 0 ? (local1 + 63) : (local1 + 63) + 0, (int) 0); + memory.writeLong((int) (local1 + 56) < 0 ? (local1 + 56) : (local1 + 56) + 0, (long) 0L); + memory.writeLong((int) (local1 + 48) < 0 ? (local1 + 48) : (local1 + 48) + 0, (long) 0L); + return local1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1246(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1246(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1247(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 68); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 28, (int) 3); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 50888); + memory.writeLong((int) (local1 + 12) < 0 ? (local1 + 12) : (local1 + 12) + 0, (long) 0L); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) 0L); + label_1: { + local2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11) & 0xFF); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0); + local2 = (local3 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 2147483632) != 0) { + break label_1; + } + local3 = (local3 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : arg0); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 10) != 0) { + break label_3; + } + arg0 = (local1 + 32); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 43, (byte) (local2)); + break label_2; + } + local4 = ((local2 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg0 = ((int) callResult_1[0]); + memory.writeI32((int) (local1 + 40) < 0 ? (local1 + 40) : (local1 + 40) + 0, (int) (local4 | -2147483648)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 32, (int) arg0); + memory.writeI32((int) (local1 + 36) < 0 ? (local1 + 36) : (local1 + 36) + 0, (int) local2); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local2) < 0 ? (((int) callResult_2[0]) + local2) : (((int) callResult_2[0]) + local2) + 0, (byte) (0)); + memory.writeI32((int) (local1 + 64) < 0 ? (local1 + 64) : (local1 + 64) + 0, (int) 0); + memory.writeLong((int) (local1 + 56) < 0 ? (local1 + 56) : (local1 + 56) + 0, (long) 0L); + memory.writeByte((int) (local1 + 52) < 0 ? (local1 + 52) : (local1 + 52) + 0, (byte) (0)); + memory.writeLong((int) (local1 + 44) < 0 ? (local1 + 44) : (local1 + 44) + 0, (long) -64L); + return local1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1247(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1247(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1248(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 148); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 28, (int) 4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 50064); + memory.writeLong((int) (local1 + 12) < 0 ? (local1 + 12) : (local1 + 12) + 0, (long) 0L); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) 0L); + label_1: { + local2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11) & 0xFF); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2), 0); + local2 = (local3 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 2147483632) != 0) { + break label_1; + } + local3 = (local3 != 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : arg0); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 10) != 0) { + break label_3; + } + arg0 = (local1 + 32); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 43, (byte) (local2)); + break label_2; + } + local4 = ((local2 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + arg0 = ((int) callResult_1[0]); + memory.writeI32((int) (local1 + 40) < 0 ? (local1 + 40) : (local1 + 40) + 0, (int) (local4 | -2147483648)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 32, (int) arg0); + memory.writeI32((int) (local1 + 36) < 0 ? (local1 + 36) : (local1 + 36) + 0, (int) local2); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + local2) < 0 ? (((int) callResult_2[0]) + local2) : (((int) callResult_2[0]) + local2) + 0, (byte) (0)); + memory.writeByte((int) (local1 + 44) < 0 ? (local1 + 44) : (local1 + 44) + 0, (byte) (0)); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (local1 + 48)); + long[] callResult_3 = instance.getMachine().call(154, callArgs_3); + memory.writeLong((int) (local1 + 116) < 0 ? (local1 + 116) : (local1 + 116) + 0, (long) 0L); + memory.writeLong((int) (local1 + 108) < 0 ? (local1 + 108) : (local1 + 108) + 0, (long) 0L); + memory.writeLong((int) (local1 + 100) < 0 ? (local1 + 100) : (local1 + 100) + 0, (long) 0L); + memory.writeLong((int) (local1 + 92) < 0 ? (local1 + 92) : (local1 + 92) + 0, (long) 0L); + memory.writeLong((int) (local1 + 84) < 0 ? (local1 + 84) : (local1 + 84) + 0, (long) 0L); + memory.writeLong((int) (local1 + 128) < 0 ? (local1 + 128) : (local1 + 128) + 0, (long) 0L); + memory.writeI32((int) (local1 + 124) < 0 ? (local1 + 124) : (local1 + 124) + 0, (int) 1065353216); + memory.writeLong((int) (local1 + 136) < 0 ? (local1 + 136) : (local1 + 136) + 0, (long) 0L); + memory.writeI32((int) (local1 + 144) < 0 ? (local1 + 144) : (local1 + 144) + 0, (int) 1065353216); + return local1; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1248(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1248(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1249(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg0) != 0) { + break label_1; + } + local2 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11) & 0xFF); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local2); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11), 0) != 0) { + break label_2; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0) { + break label_3; + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + return arg0; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_0[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1659, callArgs_0); + return ((int) callResult_0[0]); + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local3 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : local2)); + callArgs_1[1] = ((long) (local3 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : arg1)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1658, callArgs_1); + arg0 = ((int) callResult_1[0]); + } + return arg0; + } + + public static long[] call_1249(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1249(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1250(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 112); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 51, (byte) (0)); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 32, (long) 8L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 49816); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 12, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0)); + memory.writeI32((int) (local1 + 28) < 0 ? (local1 + 28) : (local1 + 28) + 0, (int) memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0)); + memory.writeByte((int) (local1 + 40) < 0 ? (local1 + 40) : (local1 + 40) + 0, (byte) (0)); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local1 + 52)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local1 + 104) < 0 ? (local1 + 104) : (local1 + 104) + 0, (long) 0L); + memory.writeLong((int) (local1 + 96) < 0 ? (local1 + 96) : (local1 + 96) + 0, (long) 0L); + memory.writeLong((int) (local1 + 88) < 0 ? (local1 + 88) : (local1 + 88) + 0, (long) 0L); + return local1; + } + + public static long[] call_1250(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1250(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1251(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 120); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 51, (byte) (0)); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 32, (long) 6L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 49940); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 12, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0)); + memory.writeI32((int) (local1 + 28) < 0 ? (local1 + 28) : (local1 + 28) + 0, (int) memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0)); + memory.writeByte((int) (local1 + 40) < 0 ? (local1 + 40) : (local1 + 40) + 0, (byte) (0)); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local1 + 52)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local1 + 112) < 0 ? (local1 + 112) : (local1 + 112) + 0, (long) 0L); + memory.writeLong((int) (local1 + 104) < 0 ? (local1 + 104) : (local1 + 104) + 0, (long) 0L); + memory.writeLong((int) (local1 + 96) < 0 ? (local1 + 96) : (local1 + 96) + 0, (long) 0L); + return local1; + } + + public static long[] call_1251(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1251(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1252(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((local2 - local3), 24); + local5 = (local4 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 178956971) != 0) { + break label_4; + } + local6 = 0; + label_5: { + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local3), 24); + local8 = (local7 << 1); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, 89478485) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local5) != 0 ? local8 : local5) : 178956970); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local5, 178956971) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local5 * 24)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local6 = ((int) callResult_0[0]); + } + local7 = (local5 * 24); + local5 = (local6 + (local4 * 24)); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), 0) != 0) { + break label_7; + } + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (int) memory.readInt((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + break label_6; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + callArgs_1[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_1[0] = ((long) local5); + instance.getMachine().call(1647, callArgs_1); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + local7 = (local6 + local7); + local6 = (local6 + (local4 * 24)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 12)); + memory.writeByte((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0, (byte) (((int) memory.read((int) (arg1 + 20) < 0 ? (arg1 + 20) : (arg1 + 20) + 0) & 0xFF))); + local8 = (local5 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_2; + } + label_8: while (true) { + local6 = (local5 + -24); + arg1 = (local2 + -24); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local4 = (arg1 + 8); + memory.writeI32((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + local5 = (local5 + -12); + local2 = (local2 + -12); + memory.writeByte((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (byte) (((int) memory.read((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0) & 0xFF))); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + local2 = arg1; + local5 = local6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg1) != 0) { + break label_1; + } + arg1 = (arg1 + -24); + label_9: while (true) { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (arg1 + 11) < 0 ? (arg1 + 11) : (arg1 + 11) + 0), -1) != 0) { + break label_10; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_2); + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local3, arg1); + arg1 = (arg1 + -24); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local5); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_11; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_5); + } + return; + } + + public static long[] call_1252(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1252(arg0, arg1, memory, instance); + return null; + } + + public static int func_1253(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + label_3: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) local2); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_0[0])) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(33, ((int) callResult_1[0])) != 0) { + break label_3; + } + local3 = (local2 + 16); + local4 = ((int) memory.read((int) (local2 + 96) < 0 ? (local2 + 96) : (local2 + 96) + 0) & 0xFF); + local5 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) (local5 + 36) < 0 ? (local5 + 36) : (local5 + 36) + 0, (byte) (0)); + local5 = (local4 ^ 1); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 96, (byte) (local5)); + local3 = (local3 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local3 < 0 ? local3 : local3 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 96, (byte) (local4)); + memory.writeByte((int) (local3 + 36) < 0 ? (local3 + 36) : (local3 + 36) + 0, (byte) (0)); + memory.writeByte((int) memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) < 0 ? memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) : memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) + 20, (byte) (1)); + label_4: { + label_5: { + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local1 + 8)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + local4 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) local2); + long[] callResult_3 = instance.getMachine().call(1191, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_5; + } + memory.writeLong((int) memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) < 0 ? memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) : memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) + 12, (long) (((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 24) & 0xFFFFFFFFL) | -4294967296L)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 44); + callArgs_4[0] = ((long) local2); + long[] callResult_4 = instance.getMachine().call(1160, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_4[0])) != 0) { + break label_4; + } + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local4); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + local4 = 1; + break label_2; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local4); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + local4 = 0; + break label_2; + } + memory.writeByte((int) memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) < 0 ? memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) : memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) + 20, (byte) (0)); + local4 = 1; + label_6: { + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) (local1 + 8)); + long[] callResult_7 = instance.getMachine().call(154, callArgs_7); + local3 = ((int) callResult_7[0]); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local3); + callArgs_8[0] = ((long) local2); + long[] callResult_8 = instance.getMachine().call(1191, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_8[0])) != 0) { + break label_6; + } + memory.writeLong((int) memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) < 0 ? memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) : memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + 0) + 12, (long) (((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 24) & 0xFFFFFFFFL) | -4294967296L)); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local3); + long[] callResult_9 = instance.getMachine().call(162, callArgs_9); + local4 = 0; + break label_2; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local3); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + } + instance.global(0).setValue(((long) (local1 + 48))); + return local4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1253(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1253(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1254(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) ((int) callResult_0[0])); + long[] callResult_1 = instance.getMachine().call(1156, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_1[0])) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 0); + local3 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local2 + 8)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1176, callArgs_2); + local4 = ((int) callResult_2[0]); + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4) != 0) { + break label_3; + } + local3 = arg1; + label_4: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local4); + local3 = (local4 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) arg0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) + 1)); + local3 = 0; + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + break label_1; + } + label_5: { + label_6: { + label_7: { + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 0); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1154, callArgs_4); + local3 = ((int) callResult_4[0]); + switch((local3 + -90)) { + case 0: + { + break label_6; + } + case 1: + { + break label_5; + } + case 2: + { + break label_5; + } + case 3: + { + break label_5; + } + case 4: + { + break label_5; + } + case 5: + { + break label_6; + } + case 6: + { + break label_5; + } + case 7: + { + break label_5; + } + case 8: + { + break label_5; + } + case 9: + { + break label_5; + } + case 10: + { + break label_5; + } + case 11: + { + break label_5; + } + case 12: + { + break label_5; + } + case 13: + { + break label_5; + } + case 14: + { + break label_5; + } + case 15: + { + break label_5; + } + case 16: + { + break label_5; + } + case 17: + { + break label_5; + } + case 18: + { + break label_5; + } + case 19: + { + break label_5; + } + case 20: + { + break label_5; + } + case 21: + { + break label_5; + } + case 22: + { + break label_5; + } + case 23: + { + break label_5; + } + case 24: + { + break label_5; + } + case 25: + { + break label_5; + } + case 26: + { + break label_5; + } + case 27: + { + break label_5; + } + case 28: + { + break label_5; + } + case 29: + { + break label_5; + } + case 30: + { + break label_5; + } + case 31: + { + break label_5; + } + case 32: + { + break label_5; + } + case 33: + { + break label_5; + } + case 34: + { + break label_5; + } + case 35: + { + break label_5; + } + case 36: + { + break label_5; + } + case 37: + { + break label_6; + } + case 38: + { + break label_6; + } + default: + { + break label_7; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(68, local3) != 0) { + break label_5; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + local3 = 1; + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local2); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1257, callArgs_5); + local4 = ((int) callResult_5[0]); + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local4) != 0) { + break label_8; + } + local3 = arg1; + label_9: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_9; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local4); + local3 = (local4 + 4); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) arg0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) + 1)); + local3 = 0; + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + 4)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg0); + ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + break label_1; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 0); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1154, callArgs_7); + local4 = ((int) callResult_7[0]); + local3 = 1; + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) 1); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1154, callArgs_8); + local5 = ((int) callResult_8[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, local4) != 0) { + break label_1; + } + label_10: { + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local5); + long[] callResult_9 = instance.getMachine().call(1156, callArgs_9); + if (((int) callResult_9[0]) != 0) { + break label_10; + } + label_11: { + switch((local5 + -90)) { + case 0: + { + break label_10; + } + case 1: + { + break label_1; + } + case 2: + { + break label_1; + } + case 3: + { + break label_1; + } + case 4: + { + break label_1; + } + case 5: + { + break label_10; + } + case 6: + { + break label_1; + } + case 7: + { + break label_1; + } + case 8: + { + break label_1; + } + case 9: + { + break label_1; + } + case 10: + { + break label_1; + } + case 11: + { + break label_1; + } + case 12: + { + break label_1; + } + case 13: + { + break label_1; + } + case 14: + { + break label_1; + } + case 15: + { + break label_1; + } + case 16: + { + break label_1; + } + case 17: + { + break label_1; + } + case 18: + { + break label_1; + } + case 19: + { + break label_1; + } + case 20: + { + break label_1; + } + case 21: + { + break label_1; + } + case 22: + { + break label_1; + } + case 23: + { + break label_1; + } + case 24: + { + break label_1; + } + case 25: + { + break label_1; + } + case 26: + { + break label_1; + } + case 27: + { + break label_1; + } + case 28: + { + break label_1; + } + case 29: + { + break label_1; + } + case 30: + { + break label_1; + } + case 31: + { + break label_1; + } + case 32: + { + break label_1; + } + case 33: + { + break label_1; + } + case 34: + { + break label_1; + } + case 35: + { + break label_1; + } + case 36: + { + break label_1; + } + case 37: + { + break label_10; + } + case 38: + { + break label_10; + } + default: + { + break label_11; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(68, local5) != 0) { + break label_1; + } + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) arg1); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1174, callArgs_10); + local3 = ((int) callResult_10[0]); + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_1254(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1254(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1255(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = ((arg0 + 16) + (local3 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_2; + } + local5 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local3 ^ 1))); + local3 = 0; + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 28); + memory.writeI32((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) 0L); + label_3: { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1196, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_0[0])) != 0) { + break label_3; + } + local5 = 0; + label_4: { + local4 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 11) & 0xFF); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local4), 0); + local4 = (local8 != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 4) : local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local4, -1) != 0) { + break label_1; + } + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local5 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) (local8 != 0 ? local3 : local2)); + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1890, callArgs_2); + local3 = (((int) callResult_2[0]) + local4); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 56); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local4 = ((int) callResult_3[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 44, (int) local5); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) (local6 + 14)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 51692); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) 0L); + memory.writeLong((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0, (long) 0L); + memory.writeLong((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (long) 64424509440L); + memory.writeI32((int) (local4 + 52) < 0 ? (local4 + 52) : (local4 + 52) + 0, (int) local3); + memory.writeI32((int) (local4 + 48) < 0 ? (local4 + 48) : (local4 + 48) + 0, (int) local3); + memory.writeI32((int) (local4 + 40) < 0 ? (local4 + 40) : (local4 + 40) + 0, (int) (local7 + -14)); + local5 = arg1; + label_5: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_5; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local3); + local5 = (local3 + 4); + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local4); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 8, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8) + 1)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 44); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1160, callArgs_4); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])); + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 11), -1) != 0) { + break label_6; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 16))); + return local5; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1255(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1255(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1256(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + long local3 = 0L; + local1 = 1; + label_1: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local2); + long[] callResult_0 = instance.getMachine().call(1156, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + label_2: { + local2 = (local2 + -68); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local2, 61) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(((1729382257048682497L >>> com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local2)) & 1L))) != 0) { + break label_1; + } + } + label_3: { + local3 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(30, (int) local3) != 0) { + break label_3; + } + return 0; + } + arg0 = (int) (local3 >>> 32L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1156, callArgs_1); + if (((int) callResult_1[0]) != 0) { + break label_1; + } + local1 = 0; + arg0 = (arg0 + -68); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, 61) != 0) { + break label_1; + } + return ((int) (1729382257048682497L >>> com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg0)) & 1); + } + return local1; + } + + public static long[] call_1256(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1256(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1257(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[10]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = (((int) instance.global(0).getValue()) - 208); + instance.global(0).setValue(((long) iL[2])); + label_1: { + iL[3] = (iL[0] + 16); + iL[4] = ((int) memory.read((int) (iL[0] + 96) < 0 ? (iL[0] + 96) : (iL[0] + 96) + 0) & 0xFF); + if (((int) memory.read((int) (iL[3] + (iL[4] * 40)) < 0 ? (iL[3] + (iL[4] * 40)) : (iL[3] + (iL[4] * 40)) + 36) & 0xFF) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + callArgs_0[0] = ((long) (iL[2] + 144)); + instance.getMachine().call(557, callArgs_0); + iL[4] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[5] = (iL[3] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) * 40)); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 144)); + memory.writeLong((int) (iL[5] + 8) < 0 ? (iL[5] + 8) : (iL[5] + 8) + 0, (long) memory.readLong((int) ((iL[2] + 144) + 8) < 0 ? ((iL[2] + 144) + 8) : ((iL[2] + 144) + 8) + 0)); + memory.writeLong((int) (iL[5] + 16) < 0 ? (iL[5] + 16) : (iL[5] + 16) + 0, (long) memory.readLong((int) ((iL[2] + 144) + 16) < 0 ? ((iL[2] + 144) + 16) : ((iL[2] + 144) + 16) + 0)); + memory.writeLong((int) (iL[5] + 24) < 0 ? (iL[5] + 24) : (iL[5] + 24) + 0, (long) memory.readLong((int) ((iL[2] + 144) + 24) < 0 ? ((iL[2] + 144) + 24) : ((iL[2] + 144) + 24) + 0)); + memory.writeI32((int) (iL[5] + 32) < 0 ? (iL[5] + 32) : (iL[5] + 32) + 0, (int) memory.readInt((int) ((iL[2] + 144) + 32) < 0 ? ((iL[2] + 144) + 32) : ((iL[2] + 144) + 32) + 0)); + label_2: { + if (((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF) != 0) { + break label_2; + } + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 36, (byte) (1)); + } + if (((int) memory.read((int) (iL[3] + (iL[4] * 40)) < 0 ? (iL[3] + (iL[4] * 40)) : (iL[3] + (iL[4] * 40)) + 36) & 0xFF) != 0) { + break label_1; + } + iL[4] = (iL[4] ^ 1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[4])); + } + label_3: { + label_4: { + label_5: { + label_6: { + iL[4] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 36) & 0xFF)) != 0) { + break label_6; + } + memory.writeLong((int) ((iL[2] + 88) + 8) < 0 ? ((iL[2] + 88) + 8) : ((iL[2] + 88) + 8) + 0, (long) memory.readLong((int) (iL[4] + 8) < 0 ? (iL[4] + 8) : (iL[4] + 8) + 0)); + memory.writeI32((int) ((iL[2] + 88) + 16) < 0 ? ((iL[2] + 88) + 16) : ((iL[2] + 88) + 16) + 0, (int) memory.readInt((int) (iL[4] + 16) < 0 ? (iL[4] + 16) : (iL[4] + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 88, (long) memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + iL[5] = 1; + label_7: { + int _d0 = func_1257__h0(iL, memory, instance); + if (_d0 == 1) + break label_3; + if (_d0 == 2) + break label_6; + if (_d0 == 3) + break label_5; + } + iL[5] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[4] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 36) & 0xFF)) != 0) { + break label_6; + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + iL[3] = ((iL[2] + 64) + 16); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (long) memory.readLong((int) (iL[4] + 16) < 0 ? (iL[4] + 16) : (iL[4] + 16) + 0)); + iL[5] = ((iL[2] + 64) + 8); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) (iL[4] + 8) < 0 ? (iL[4] + 8) : (iL[4] + 8) + 0)); + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 64, (long) memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 136, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 24)); + label_24: { + long[] callArgs_59 = new long[2]; + callArgs_59[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12)); + callArgs_59[0] = ((long) (iL[2] + 136)); + long[] callResult_59 = instance.getMachine().call(194, callArgs_59); + if (((int) callResult_59[0]) != 0) { + break label_24; + } + iL[4] = ((iL[2] + 112) + 16); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + iL[3] = ((iL[2] + 112) + 8); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (long) memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 112, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 64)); + long[] callArgs_60 = new long[2]; + callArgs_60[1] = ((long) (iL[2] + 136)); + callArgs_60[0] = ((long) (iL[2] + 144)); + instance.getMachine().call(192, callArgs_60); + memory.writeLong((int) ((iL[2] + 40) + 8) < 0 ? ((iL[2] + 40) + 8) : ((iL[2] + 40) + 8) + 0, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + memory.writeI32((int) ((iL[2] + 40) + 16) < 0 ? ((iL[2] + 40) + 16) : ((iL[2] + 40) + 16) + 0, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 40, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 112)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 32, (int) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 144)); + long[] callArgs_61 = new long[4]; + callArgs_61[3] = ((long) (iL[2] + 32)); + callArgs_61[2] = ((long) 11125); + callArgs_61[1] = ((long) (iL[2] + 40)); + callArgs_61[0] = ((long) iL[0]); + instance.getMachine().call(1151, callArgs_61); + } + long[] callArgs_62 = new long[1]; + callArgs_62[0] = ((long) 196); + long[] callResult_62 = instance.getMachine().call(1776, callArgs_62); + iL[4] = ((int) callResult_62[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 4, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 32, (int) 62); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 36, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) 58148); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 88)); + memory.writeLong((int) (iL[4] + 20) < 0 ? (iL[4] + 20) : (iL[4] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 88) + 8) < 0 ? ((iL[2] + 88) + 8) : ((iL[2] + 88) + 8) + 0)); + memory.writeI32((int) (iL[4] + 28) < 0 ? (iL[4] + 28) : (iL[4] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 88) + 16) < 0 ? ((iL[2] + 88) + 16) : ((iL[2] + 88) + 16) + 0)); + memory.writeLong((int) (iL[4] + 41) < 0 ? (iL[4] + 41) : (iL[4] + 41) + 0, (long) 0L); + long[] callArgs_63 = new long[1]; + callArgs_63[0] = ((long) (iL[4] + 52)); + long[] callResult_63 = instance.getMachine().call(154, callArgs_63); + memory.writeLong((int) (iL[4] + 120) < 0 ? (iL[4] + 120) : (iL[4] + 120) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 112) < 0 ? (iL[4] + 112) : (iL[4] + 112) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 104) < 0 ? (iL[4] + 104) : (iL[4] + 104) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 96) < 0 ? (iL[4] + 96) : (iL[4] + 96) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 88) < 0 ? (iL[4] + 88) : (iL[4] + 88) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 132) < 0 ? (iL[4] + 132) : (iL[4] + 132) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 128) < 0 ? (iL[4] + 128) : (iL[4] + 128) + 0, (int) 1065353216); + memory.writeLong((int) (iL[4] + 140) < 0 ? (iL[4] + 140) : (iL[4] + 140) + 0, (long) 0L); + iL[3] = (iL[4] + 152); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 148) < 0 ? (iL[4] + 148) : (iL[4] + 148) + 0, (int) 1065353216); + memory.writeLong((int) (iL[4] + 160) < 0 ? (iL[4] + 160) : (iL[4] + 160) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 168) < 0 ? (iL[4] + 168) : (iL[4] + 168) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 176) < 0 ? (iL[4] + 176) : (iL[4] + 176) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 184) < 0 ? (iL[4] + 184) : (iL[4] + 184) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 192) < 0 ? (iL[4] + 192) : (iL[4] + 192) + 0, (int) 0); + label_25: { + iL[5] = (iL[4] + 36); + long[] callArgs_64 = new long[2]; + callArgs_64[1] = ((long) iL[5]); + callArgs_64[0] = ((long) iL[0]); + long[] callResult_64 = instance.getMachine().call(1178, callArgs_64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_64[0])) != 0) { + break label_25; + } + long[] callArgs_65 = new long[2]; + callArgs_65[1] = ((long) (iL[4] + 48)); + callArgs_65[0] = ((long) iL[0]); + long[] callResult_65 = instance.getMachine().call(1180, callArgs_65); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_65[0])) != 0) { + break label_25; + } + long[] callArgs_66 = new long[2]; + callArgs_66[1] = ((long) (iL[4] + 184)); + callArgs_66[0] = ((long) iL[0]); + long[] callResult_66 = instance.getMachine().call(1182, callArgs_66); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_66[0])) != 0) { + break label_25; + } + long[] callArgs_67 = new long[2]; + callArgs_67[1] = ((long) iL[3]); + callArgs_67[0] = ((long) iL[0]); + long[] callResult_67 = instance.getMachine().call(1175, callArgs_67); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_67[0])) != 0) { + break label_25; + } + long[] callArgs_68 = new long[2]; + callArgs_68[1] = ((long) 87); + callArgs_68[0] = ((long) iL[0]); + long[] callResult_68 = instance.getMachine().call(1160, callArgs_68); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_68[0])) != 0) { + break label_25; + } + long[] callArgs_69 = new long[2]; + callArgs_69[1] = ((long) iL[5]); + callArgs_69[0] = ((long) iL[0]); + long[] callResult_69 = instance.getMachine().call(1297, callArgs_69); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_69[0])) != 0) { + break label_25; + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + iL[5] = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_3; + } + int ciTableIdx_70 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_70 = instance.table(0).requiredRef(ciTableIdx_70); + com.dylibso.chicory.runtime.Instance ciRefInstance_70 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_70), instance); + if (!ciRefInstance_70.type(ciRefInstance_70.functionType(ciFuncId_70)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_70 = new long[1]; + callArgs_70[0] = ((long) iL[0]); + ciRefInstance_70.getMachine().call(ciFuncId_70, callArgs_70); + break label_3; + } + int ciTableIdx_71 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 4)); + int ciFuncId_71 = instance.table(0).requiredRef(ciTableIdx_71); + com.dylibso.chicory.runtime.Instance ciRefInstance_71 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_71), instance); + if (!ciRefInstance_71.type(ciRefInstance_71.functionType(ciFuncId_71)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_71 = new long[1]; + callArgs_71[0] = ((long) iL[4]); + ciRefInstance_71.getMachine().call(ciFuncId_71, callArgs_71); + break label_4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + int ciTableIdx_73 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 4)); + int ciFuncId_73 = instance.table(0).requiredRef(ciTableIdx_73); + com.dylibso.chicory.runtime.Instance ciRefInstance_73 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_73), instance); + if (!ciRefInstance_73.type(ciRefInstance_73.functionType(ciFuncId_73)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_73 = new long[1]; + callArgs_73[0] = ((long) iL[4]); + ciRefInstance_73.getMachine().call(ciFuncId_73, callArgs_73); + } + iL[5] = 1; + } + instance.global(0).setValue(((long) (iL[2] + 208))); + return iL[5]; + } + + public static long[] call_1257(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1257(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1258(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) 0); + label_1: { + label_2: { + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_2; + } + local3 = (local2 - local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local3, -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local3); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local2 + ((local3 >> 3) << 3))); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + label_3: { + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local3) != 0) { + break label_3; + } + label_4: while (true) { + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + local2 = (local2 + 8); + local3 = (local3 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + } + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1258(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1258(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1259(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long local3 = 0L; + int local4 = 0; + long local5 = 0L; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48848); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + local3 = memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0); + local4 = memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0); + local5 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 32, (long) 42L); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) local4); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) local3); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) local5); + memory.writeLong((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48664); + label_1: { + label_2: { + arg2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, arg2) != 0) { + break label_2; + } + local4 = (arg2 - local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local4, -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + arg2 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 40, (int) arg2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 44, (int) (arg2 + ((local4 >> 3) << 3))); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) arg2); + label_3: { + local4 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local4) != 0) { + break label_3; + } + label_4: while (true) { + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + arg2 = (arg2 + 8); + local4 = (local4 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 40, (int) arg2); + } + return arg0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1259(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1259(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1260(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 9); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 52000); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1260(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1260(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1261(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 10); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 52112); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1261(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1261(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1262(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 84); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 32, (int) 11); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 36, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 52224); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 12, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0)); + memory.writeI32((int) (local1 + 28) < 0 ? (local1 + 28) : (local1 + 28) + 0, (int) memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0)); + memory.writeI32((int) (local1 + 44) < 0 ? (local1 + 44) : (local1 + 44) + 0, (int) 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local1 + 48)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + return local1; + } + + public static long[] call_1262(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1262(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1263(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 12); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 52392); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1263(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1263(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1264(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 176); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 32, (int) 13); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 36, (byte) (0)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 52504); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 12, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0)); + memory.writeI32((int) (local1 + 28) < 0 ? (local1 + 28) : (local1 + 28) + 0, (int) memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0)); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local1 + 40)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local1 + 108) < 0 ? (local1 + 108) : (local1 + 108) + 0, (long) 0L); + memory.writeLong((int) (local1 + 100) < 0 ? (local1 + 100) : (local1 + 100) + 0, (long) 0L); + memory.writeLong((int) (local1 + 92) < 0 ? (local1 + 92) : (local1 + 92) + 0, (long) 0L); + memory.writeLong((int) (local1 + 84) < 0 ? (local1 + 84) : (local1 + 84) + 0, (long) 0L); + memory.writeLong((int) (local1 + 76) < 0 ? (local1 + 76) : (local1 + 76) + 0, (long) 0L); + memory.writeLong((int) (local1 + 120) < 0 ? (local1 + 120) : (local1 + 120) + 0, (long) 0L); + memory.writeI32((int) (local1 + 116) < 0 ? (local1 + 116) : (local1 + 116) + 0, (int) 1065353216); + memory.writeLong((int) (local1 + 128) < 0 ? (local1 + 128) : (local1 + 128) + 0, (long) 0L); + memory.writeI32((int) (local1 + 136) < 0 ? (local1 + 136) : (local1 + 136) + 0, (int) 1065353216); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local1 + 140)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + return local1; + } + + public static long[] call_1264(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1264(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1265(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 40); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 52608); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1265(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1265(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1266(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 176); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local1 = ((int) callResult_0[0]); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 4, (long) 0L); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 32, (int) 41); + memory.writeByte((int) local1 < 0 ? local1 : local1 + 36, (byte) (0)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) 52720); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 12, (long) memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0)); + memory.writeLong((int) (local1 + 20) < 0 ? (local1 + 20) : (local1 + 20) + 0, (long) memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0)); + memory.writeI32((int) (local1 + 28) < 0 ? (local1 + 28) : (local1 + 28) + 0, (int) memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0)); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local1 + 40)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + memory.writeLong((int) (local1 + 108) < 0 ? (local1 + 108) : (local1 + 108) + 0, (long) 0L); + memory.writeLong((int) (local1 + 100) < 0 ? (local1 + 100) : (local1 + 100) + 0, (long) 0L); + memory.writeLong((int) (local1 + 92) < 0 ? (local1 + 92) : (local1 + 92) + 0, (long) 0L); + memory.writeLong((int) (local1 + 84) < 0 ? (local1 + 84) : (local1 + 84) + 0, (long) 0L); + memory.writeLong((int) (local1 + 76) < 0 ? (local1 + 76) : (local1 + 76) + 0, (long) 0L); + memory.writeLong((int) (local1 + 120) < 0 ? (local1 + 120) : (local1 + 120) + 0, (long) 0L); + memory.writeI32((int) (local1 + 116) < 0 ? (local1 + 116) : (local1 + 116) + 0, (int) 1065353216); + memory.writeLong((int) (local1 + 128) < 0 ? (local1 + 128) : (local1 + 128) + 0, (long) 0L); + memory.writeI32((int) (local1 + 136) < 0 ? (local1 + 136) : (local1 + 136) + 0, (int) 1065353216); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local1 + 140)); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + return local1; + } + + public static long[] call_1266(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1266(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1267(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 24); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 52832); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1267(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1267(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1268(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 25); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 52944); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1268(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1268(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1269(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 26); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 53056); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1269(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1269(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1270(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 20); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 53168); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1270(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1270(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1271(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 21); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 53280); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1271(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1271(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1272(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 80)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + arg2 = ((int) callResult_0[0]); + local6 = (arg1 + 8); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + local7 = (arg1 + 16); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local8 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 72)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1197, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local4 + 64)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1198, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 96); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg0 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local8 = ((int) callResult_5[0]); + local9 = memory.readLong((int) local4 < 0 ? local4 : local4 + 64); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 72); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local8); + callArgs_6[0] = ((long) (local4 + 120)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local11 = ((int) callResult_6[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 23); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53564); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local11); + callArgs_7[0] = ((long) (arg0 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local11); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) local10); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 80, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53392); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg0); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local8); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local8 = 0; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg2); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local4 + 160))); + return local8; + } + + public static long[] call_1272(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1272(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1273(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 80)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + arg2 = ((int) callResult_0[0]); + local6 = (arg1 + 8); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + local7 = (arg1 + 16); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local8 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 72)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1197, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local4 + 64)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1198, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 96); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg0 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local8 = ((int) callResult_5[0]); + local9 = memory.readLong((int) local4 < 0 ? local4 : local4 + 64); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 72); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local8); + callArgs_6[0] = ((long) (local4 + 120)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local11 = ((int) callResult_6[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 49); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53752); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local11); + callArgs_7[0] = ((long) (arg0 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local11); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) local10); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 80, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53580); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg0); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local8); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local8 = 0; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg2); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local4 + 160))); + return local8; + } + + public static long[] call_1273(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1273(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1274(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + long local9 = 0L; + local3 = (((int) instance.global(0).getValue()) - 256); + instance.global(0).setValue(((long) local3)); + label_1: { + local4 = (arg0 + 16); + local5 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local6 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF)) != 0) { + break label_1; + } + local5 = (local5 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + memory.writeLong((int) ((local3 + 136) + 16) < 0 ? ((local3 + 136) + 16) : ((local3 + 136) + 16) + 0, (long) memory.readLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) ((local3 + 136) + 8) < 0 ? ((local3 + 136) + 8) : ((local3 + 136) + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + memory.writeByte((int) local6 < 0 ? local6 : local6 + 36, (byte) (0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 136, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + label_2: { + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_0[0] = ((long) (local3 + 192)); + instance.getMachine().call(557, callArgs_0); + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local6 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) * 40)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 192)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) ((local3 + 192) + 8) < 0 ? ((local3 + 192) + 8) : ((local3 + 192) + 8) + 0)); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) memory.readLong((int) ((local3 + 192) + 16) < 0 ? ((local3 + 192) + 16) : ((local3 + 192) + 16) + 0)); + memory.writeLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0, (long) memory.readLong((int) ((local3 + 192) + 24) < 0 ? ((local3 + 192) + 24) : ((local3 + 192) + 24) + 0)); + memory.writeI32((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0, (int) memory.readInt((int) ((local3 + 192) + 32) < 0 ? ((local3 + 192) + 32) : ((local3 + 192) + 32) + 0)); + label_3: { + if (((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF) != 0) { + break label_3; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_2; + } + local5 = (local5 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + } + local6 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF)) != 0) { + break label_1; + } + local8 = memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0); + local9 = memory.readLong((int) local6 < 0 ? local6 : local6 + 0); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) memory.readInt((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (long) local8); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local9); + label_4: { + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local3 + 192)); + instance.getMachine().call(557, callArgs_1); + local5 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local6 = (local4 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) * 40)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 192)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) ((local3 + 192) + 8) < 0 ? ((local3 + 192) + 8) : ((local3 + 192) + 8) + 0)); + memory.writeLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (long) memory.readLong((int) ((local3 + 192) + 16) < 0 ? ((local3 + 192) + 16) : ((local3 + 192) + 16) + 0)); + memory.writeLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0, (long) memory.readLong((int) ((local3 + 192) + 24) < 0 ? ((local3 + 192) + 24) : ((local3 + 192) + 24) + 0)); + memory.writeI32((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0, (int) memory.readInt((int) ((local3 + 192) + 32) < 0 ? ((local3 + 192) + 32) : ((local3 + 192) + 32) + 0)); + label_5: { + if (((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF) != 0) { + break label_5; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local4 + (local5 * 40)) < 0 ? (local4 + (local5 * 40)) : (local4 + (local5 * 40)) + 36) & 0xFF) != 0) { + break label_4; + } + local5 = (local5 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local5)); + } + local6 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local6 < 0 ? local6 : local6 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeI32((int) ((local3 + 96) + 32) < 0 ? ((local3 + 96) + 32) : ((local3 + 96) + 32) + 0, (int) memory.readInt((int) (local6 + 32) < 0 ? (local6 + 32) : (local6 + 32) + 0)); + memory.writeLong((int) ((local3 + 96) + 24) < 0 ? ((local3 + 96) + 24) : ((local3 + 96) + 24) + 0, (long) memory.readLong((int) (local6 + 24) < 0 ? (local6 + 24) : (local6 + 24) + 0)); + memory.writeLong((int) ((local3 + 96) + 16) < 0 ? ((local3 + 96) + 16) : ((local3 + 96) + 16) + 0, (long) memory.readLong((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0)); + memory.writeLong((int) ((local3 + 96) + 8) < 0 ? ((local3 + 96) + 8) : ((local3 + 96) + 8) + 0, (long) memory.readLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 96, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(231, local7) != 0) { + break label_10; + } + label_11: { + label_12: { + local6 = (memory.readInt((int) local3 < 0 ? local3 : local3 + 116) + -34); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 25) != 0) { + break label_12; + } + if (((1 << local6) & 58720259) != 0) { + break label_11; + } + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 32); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 17, (byte) (0)); + memory.writeByte((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 13529) & 0xFF))); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 13521)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 13513)); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 12); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg1 = ((int) callResult_3[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 192, (int) arg1); + local6 = (arg1 + 12); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 200, (int) local6); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 17); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(1647, callArgs_4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 196, (int) local6); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 27622); + callArgs_5[1] = ((long) (local3 + 192)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1163, callArgs_5); + local6 = ((int) callResult_5[0]); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_13; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_6); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_8); + break label_6; + } + local6 = 1; + label_14: { + label_15: { + label_16: { + switch((local7 + -57)) { + case 0: + { + break label_16; + } + case 1: + { + break label_15; + } + case 2: + { + break label_9; + } + case 3: + { + break label_14; + } + default: + { + break label_6; + } + } + } + local4 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((memory.readInt((int) local4 < 0 ? local4 : local4 + 20) + -57), 2) != 0) { + break label_7; + } + local8 = memory.readLong((int) local4 < 0 ? local4 : local4 + 28); + local4 = (int) local8; + long[] callArgs_9 = new long[4]; + callArgs_9[3] = ((long) 1); + callArgs_9[2] = ((long) (local3 + 192)); + callArgs_9[1] = ((long) (local4 + (int) (local8 >>> 32L))); + callArgs_9[0] = ((long) local4); + long[] callResult_9 = instance.getMachine().call(551, callArgs_9); + local4 = ((int) callResult_9[0]); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 52, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -1L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 192)); + break label_8; + } + local4 = (local4 + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((memory.readInt((int) local4 < 0 ? local4 : local4 + 20) + -57), 2) != 0) { + break label_7; + } + local8 = memory.readLong((int) local4 < 0 ? local4 : local4 + 28); + local4 = (int) local8; + long[] callArgs_10 = new long[4]; + callArgs_10[3] = ((long) 1); + callArgs_10[2] = ((long) (local3 + 192)); + callArgs_10[1] = ((long) (local4 + (int) (local8 >>> 32L))); + callArgs_10[0] = ((long) local4); + long[] callResult_10 = instance.getMachine().call(548, callArgs_10); + local4 = ((int) callResult_10[0]); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 52, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -2L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 36, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 192)); + break label_8; + } + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) arg2); + callArgs_11[1] = ((long) arg1); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1300, callArgs_11); + local4 = ((int) callResult_11[0]); + break label_8; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 184, (int) 231); + label_17: { + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + callArgs_12[0] = ((long) (local3 + 184)); + long[] callResult_12 = instance.getMachine().call(194, callArgs_12); + if (((int) callResult_12[0]) != 0) { + break label_17; + } + local4 = ((local3 + 160) + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) ((local3 + 136) + 16) < 0 ? ((local3 + 136) + 16) : ((local3 + 136) + 16) + 0)); + local6 = ((local3 + 160) + 8); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) ((local3 + 136) + 8) < 0 ? ((local3 + 136) + 8) : ((local3 + 136) + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 160, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 136)); + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) (local3 + 184)); + callArgs_13[0] = ((long) (local3 + 192)); + instance.getMachine().call(192, callArgs_13); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 160)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 192)); + long[] callArgs_14 = new long[4]; + callArgs_14[3] = ((long) local3); + callArgs_14[2] = ((long) 11125); + callArgs_14[1] = ((long) (local3 + 8)); + callArgs_14[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_14); + } + long[] callArgs_15 = new long[4]; + callArgs_15[3] = ((long) arg2); + callArgs_15[2] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 116)); + callArgs_15[1] = ((long) arg1); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1301, callArgs_15); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_15[0])); + break label_6; + } + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) arg2); + callArgs_16[1] = ((long) arg1); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1302, callArgs_16); + local4 = ((int) callResult_16[0]); + } + local6 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local4) != 0) { + break label_6; + } + } + local4 = ((local3 + 72) + 16); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + local6 = ((local3 + 72) + 8); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 72, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) (local3 + 96)); + callArgs_17[0] = ((long) (local3 + 192)); + instance.getMachine().call(544, callArgs_17); + memory.writeLong((int) ((local3 + 48) + 8) < 0 ? ((local3 + 48) + 8) : ((local3 + 48) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) ((local3 + 48) + 16) < 0 ? ((local3 + 48) + 16) : ((local3 + 48) + 16) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 72)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 203), 0) != 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 192) : (local3 + 192))); + long[] callArgs_18 = new long[4]; + callArgs_18[3] = ((long) (local3 + 32)); + callArgs_18[2] = ((long) 30899); + callArgs_18[1] = ((long) (local3 + 48)); + callArgs_18[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_18); + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 203), -1) != 0) { + break label_18; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 192)); + instance.getMachine().call(1777, callArgs_19); + } + local6 = 1; + } + instance.global(0).setValue(((long) (local3 + 256))); + return local6; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1274(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1274(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1275(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local3 = (((int) instance.global(0).getValue()) - 208); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 168)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + 128)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + local5 = ((int) callResult_1[0]); + local6 = (arg1 + 16); + memory.writeI32((int) ((local3 + 24) + 16) < 0 ? ((local3 + 24) + 16) : ((local3 + 24) + 16) + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + local7 = (arg1 + 8); + memory.writeLong((int) ((local3 + 24) + 8) < 0 ? ((local3 + 24) + 8) : ((local3 + 24) + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local8 = 1; + label_1: { + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) (local3 + 24)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1199, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_2[0])) != 0) { + break label_1; + } + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local8 = 1; + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local5); + callArgs_3[1] = ((long) local3); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1199, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_1; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 108); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + local8 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local4); + callArgs_5[0] = ((long) (local3 + 88)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + arg0 = ((int) callResult_5[0]); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local5); + callArgs_6[0] = ((long) (local3 + 48)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local6 = ((int) callResult_6[0]); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 4, (long) 0L); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 32, (int) 28); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) 54232); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local8 + 20) < 0 ? (local8 + 20) : (local8 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local8 + 28) < 0 ? (local8 + 28) : (local8 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg0); + callArgs_7[0] = ((long) (local8 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local6); + callArgs_8[0] = ((long) (local8 + 72)); + long[] callResult_8 = instance.getMachine().call(159, callArgs_8); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local8); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local6); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + local8 = 0; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local5); + long[] callResult_12 = instance.getMachine().call(162, callArgs_12); + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local4); + long[] callResult_13 = instance.getMachine().call(162, callArgs_13); + instance.global(0).setValue(((long) (local3 + 208))); + return local8; + } + + public static long[] call_1275(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1275(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1276(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 72)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (arg1 + 16); + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + local6 = (arg1 + 8); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local7 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) (local3 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local7 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (local3 + 32)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg0 = ((int) callResult_3[0]); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) 30); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 54356); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (local7 + 28) < 0 ? (local7 + 28) : (local7 + 28) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg0); + callArgs_4[0] = ((long) (local7 + 36)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local7); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + local7 = 0; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local3 + 112))); + return local7; + } + + public static long[] call_1276(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1276(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1277(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 29); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 54472); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1277(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1277(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1278(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 352); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 272)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local4 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + 232)); + long[] callResult_1 = instance.getMachine().call(154, callArgs_1); + local5 = ((int) callResult_1[0]); + label_1: { + label_2: { + label_3: { + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1154, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_2[0])) != 0) { + break label_3; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1154, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(31, ((int) callResult_3[0])) != 0) { + break label_3; + } + label_4: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 15) & 0xFF) != 0) { + break label_4; + } + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) 0); + callArgs_4[2] = ((long) 18254); + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_4); + local6 = 1; + break label_1; + } + memory.writeI32((int) ((local3 + 24) + 16) < 0 ? ((local3 + 24) + 16) : ((local3 + 24) + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) ((local3 + 24) + 8) < 0 ? ((local3 + 24) + 8) : ((local3 + 24) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 24, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local6 = 1; + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local4); + callArgs_5[1] = ((long) (local3 + 24)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1199, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_1; + } + local6 = 1; + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local5); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1166, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_6[0])) != 0) { + break label_1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) 108); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + arg0 = ((int) callResult_7[0]); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local4); + callArgs_8[0] = ((long) (local3 + 192)); + long[] callResult_8 = instance.getMachine().call(159, callArgs_8); + local7 = ((int) callResult_8[0]); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local7); + callArgs_9[0] = ((long) (local3 + 312)); + long[] callResult_9 = instance.getMachine().call(159, callArgs_9); + local6 = ((int) callResult_9[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 32); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54756); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) local6); + callArgs_10[0] = ((long) (arg0 + 36)); + long[] callResult_10 = instance.getMachine().call(159, callArgs_10); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local6); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54584); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) local5); + callArgs_12[0] = ((long) (arg0 + 72)); + long[] callResult_12 = instance.getMachine().call(159, callArgs_12); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg0); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + int ciTableIdx_13 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_13 = instance.table(0).requiredRef(ciTableIdx_13); + com.dylibso.chicory.runtime.Instance ciRefInstance_13 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_13), instance); + if (!ciRefInstance_13.type(ciRefInstance_13.functionType(ciFuncId_13)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) arg1); + ciRefInstance_13.getMachine().call(ciFuncId_13, callArgs_13); + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local7); + long[] callResult_14 = instance.getMachine().call(162, callArgs_14); + break label_2; + } + local6 = 1; + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) local4); + callArgs_15[0] = ((long) arg0); + long[] callResult_15 = instance.getMachine().call(1166, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_15[0])) != 0) { + break label_1; + } + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) arg1); + callArgs_16[1] = ((long) 0); + callArgs_16[0] = ((long) (local3 + 152)); + long[] callResult_16 = instance.getMachine().call(155, callArgs_16); + local7 = ((int) callResult_16[0]); + label_6: { + label_7: { + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) 0); + callArgs_17[0] = ((long) arg0); + long[] callResult_17 = instance.getMachine().call(1154, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(59, ((int) callResult_17[0])) != 0) { + break label_7; + } + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) 0); + callArgs_18[0] = ((long) arg0); + long[] callResult_18 = instance.getMachine().call(1154, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(136, ((int) callResult_18[0])) != 0) { + break label_6; + } + } + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) local5); + callArgs_19[0] = ((long) arg0); + long[] callResult_19 = instance.getMachine().call(1166, callArgs_19); + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) local7); + long[] callResult_20 = instance.getMachine().call(162, callArgs_20); + label_8: { + if (((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 15) & 0xFF) != 0) { + break label_8; + } + memory.writeI32((int) ((local3 + 48) + 16) < 0 ? ((local3 + 48) + 16) : ((local3 + 48) + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) ((local3 + 48) + 8) < 0 ? ((local3 + 48) + 8) : ((local3 + 48) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 48, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_21 = new long[4]; + callArgs_21[3] = ((long) 0); + callArgs_21[2] = ((long) 18211); + callArgs_21[1] = ((long) (local3 + 48)); + callArgs_21[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_21); + break label_1; + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) 108); + long[] callResult_22 = instance.getMachine().call(1776, callArgs_22); + arg0 = ((int) callResult_22[0]); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) local4); + callArgs_23[0] = ((long) (local3 + 112)); + long[] callResult_23 = instance.getMachine().call(159, callArgs_23); + local7 = ((int) callResult_23[0]); + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) local7); + callArgs_24[0] = ((long) (local3 + 312)); + long[] callResult_24 = instance.getMachine().call(159, callArgs_24); + local6 = ((int) callResult_24[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 32); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54756); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) local6); + callArgs_25[0] = ((long) (arg0 + 36)); + long[] callResult_25 = instance.getMachine().call(159, callArgs_25); + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) local6); + long[] callResult_26 = instance.getMachine().call(162, callArgs_26); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54584); + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) local5); + callArgs_27[0] = ((long) (arg0 + 72)); + long[] callResult_27 = instance.getMachine().call(159, callArgs_27); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg0); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_9; + } + int ciTableIdx_28 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_28 = instance.table(0).requiredRef(ciTableIdx_28); + com.dylibso.chicory.runtime.Instance ciRefInstance_28 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_28), instance); + if (!ciRefInstance_28.type(ciRefInstance_28.functionType(ciFuncId_28)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) arg1); + ciRefInstance_28.getMachine().call(ciFuncId_28, callArgs_28); + } + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) local7); + long[] callResult_29 = instance.getMachine().call(162, callArgs_29); + break label_2; + } + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) local7); + callArgs_30[0] = ((long) local5); + long[] callResult_30 = instance.getMachine().call(160, callArgs_30); + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) local7); + long[] callResult_31 = instance.getMachine().call(162, callArgs_31); + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) 108); + long[] callResult_32 = instance.getMachine().call(1776, callArgs_32); + arg0 = ((int) callResult_32[0]); + long[] callArgs_33 = new long[2]; + callArgs_33[1] = ((long) local5); + callArgs_33[0] = ((long) (local3 + 72)); + long[] callResult_33 = instance.getMachine().call(159, callArgs_33); + local7 = ((int) callResult_33[0]); + long[] callArgs_34 = new long[2]; + callArgs_34[1] = ((long) local7); + callArgs_34[0] = ((long) (local3 + 312)); + long[] callResult_34 = instance.getMachine().call(159, callArgs_34); + local6 = ((int) callResult_34[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 32); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54756); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_35 = new long[2]; + callArgs_35[1] = ((long) local6); + callArgs_35[0] = ((long) (arg0 + 36)); + long[] callResult_35 = instance.getMachine().call(159, callArgs_35); + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) local6); + long[] callResult_36 = instance.getMachine().call(162, callArgs_36); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54584); + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) local4); + callArgs_37[0] = ((long) (arg0 + 72)); + long[] callResult_37 = instance.getMachine().call(159, callArgs_37); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) arg0); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_10; + } + int ciTableIdx_38 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_38 = instance.table(0).requiredRef(ciTableIdx_38); + com.dylibso.chicory.runtime.Instance ciRefInstance_38 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_38), instance); + if (!ciRefInstance_38.type(ciRefInstance_38.functionType(ciFuncId_38)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_38 = new long[1]; + callArgs_38[0] = ((long) arg1); + ciRefInstance_38.getMachine().call(ciFuncId_38, callArgs_38); + } + long[] callArgs_39 = new long[1]; + callArgs_39[0] = ((long) local7); + long[] callResult_39 = instance.getMachine().call(162, callArgs_39); + } + local6 = 0; + } + long[] callArgs_40 = new long[1]; + callArgs_40[0] = ((long) local5); + long[] callResult_40 = instance.getMachine().call(162, callArgs_40); + long[] callArgs_41 = new long[1]; + callArgs_41[0] = ((long) local4); + long[] callResult_41 = instance.getMachine().call(162, callArgs_41); + instance.global(0).setValue(((long) (local3 + 352))); + return local6; + } + + public static long[] call_1278(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1278(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1279(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 72)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (arg1 + 16); + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + local6 = (arg1 + 8); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local7 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) (local3 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local7 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (local3 + 32)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg0 = ((int) callResult_3[0]); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) 33); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 54772); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (local7 + 28) < 0 ? (local7 + 28) : (local7 + 28) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg0); + callArgs_4[0] = ((long) (local7 + 36)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local7); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + local7 = 0; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local3 + 112))); + return local7; + } + + public static long[] call_1279(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1279(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1280(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local3)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 72)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local4 = ((int) callResult_0[0]); + local5 = (arg1 + 16); + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + local6 = (arg1 + 8); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local7 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) (local3 + 8)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local7 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local4); + callArgs_3[0] = ((long) (local3 + 32)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg0 = ((int) callResult_3[0]); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) 31); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 54888); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (local7 + 28) < 0 ? (local7 + 28) : (local7 + 28) + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) arg0); + callArgs_4[0] = ((long) (local7 + 36)); + long[] callResult_4 = instance.getMachine().call(159, callArgs_4); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local7); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg1); + ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + local7 = 0; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local4); + long[] callResult_7 = instance.getMachine().call(162, callArgs_7); + instance.global(0).setValue(((long) (local3 + 112))); + return local7; + } + + public static long[] call_1280(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1280(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1281(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48848); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 50); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49060); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (arg0 + 72)); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + return arg0; + } + + public static long[] call_1281(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1281(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1282(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 51); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 55004); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1282(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1282(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1283(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local2)); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg0); + callArgs_0[0] = ((long) (local2 + 8)); + long[] callResult_0 = instance.getMachine().call(157, callArgs_0); + local3 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(158, callArgs_1); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local3); + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(158, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + instance.global(0).setValue(((long) (local2 + 48))); + return; + } + + public static long[] call_1283(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1283(arg0, arg1, memory, instance); + return null; + } + + public static int func_1284(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48848); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg3 < 0 ? arg3 : arg3 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 52); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49160); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(159, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) (arg0 + 72)); + long[] callResult_1 = instance.getMachine().call(159, callArgs_1); + return arg0; + } + + public static long[] call_1284(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1284(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1285(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 36); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 49596); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1285(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1285(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1286(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 59); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 55864); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1286(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1286(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1287(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 48); + instance.global(0).setValue(((long) local3)); + local4 = 1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + 8)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1166, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 72); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 4, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 38); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 56044); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (local4 + 20) < 0 ? (local4 + 20) : (local4 + 20) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeI32((int) (local4 + 28) < 0 ? (local4 + 28) : (local4 + 28) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local5); + callArgs_3[0] = ((long) (local4 + 36)); + long[] callResult_3 = instance.getMachine().call(159, callArgs_3); + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) local4); + local4 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg1); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + instance.global(0).setValue(((long) (local3 + 48))); + return local4; + } + + public static long[] call_1287(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1287(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1288(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 80)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + arg2 = ((int) callResult_0[0]); + local6 = (arg1 + 8); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + local7 = (arg1 + 16); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local8 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 72)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1197, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local4 + 64)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1198, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 96); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg0 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local8 = ((int) callResult_5[0]); + local9 = memory.readLong((int) local4 < 0 ? local4 : local4 + 64); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 72); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local8); + callArgs_6[0] = ((long) (local4 + 120)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local11 = ((int) callResult_6[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56324); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local11); + callArgs_7[0] = ((long) (arg0 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local11); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) local10); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 80, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56156); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg0); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local8); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local8 = 0; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg2); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local4 + 160))); + return local8; + } + + public static long[] call_1288(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1288(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1289(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 80)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + arg2 = ((int) callResult_0[0]); + local6 = (arg1 + 8); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + local7 = (arg1 + 16); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local8 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 72)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1197, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local4 + 64)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1198, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 96); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg0 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local8 = ((int) callResult_5[0]); + local9 = memory.readLong((int) local4 < 0 ? local4 : local4 + 64); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 72); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local8); + callArgs_6[0] = ((long) (local4 + 120)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local11 = ((int) callResult_6[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56508); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local11); + callArgs_7[0] = ((long) (arg0 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local11); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) local10); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 80, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56340); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg0); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local8); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local8 = 0; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg2); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local4 + 160))); + return local8; + } + + public static long[] call_1289(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1289(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1290(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + long local11 = 0L; + int local12 = 0; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 80)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + arg2 = ((int) callResult_0[0]); + local6 = (arg1 + 8); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + local7 = (arg1 + 16); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local8 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 72)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1197, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local4 + 64)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1198, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 96); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg0 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local9 = ((int) callResult_5[0]); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 64); + local11 = memory.readLong((int) local4 < 0 ? local4 : local4 + 72); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local9); + callArgs_6[0] = ((long) (local4 + 120)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local12 = ((int) callResult_6[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + local8 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56692); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local12); + callArgs_7[0] = ((long) (arg0 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local12); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) local11); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 80, (long) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56524); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg0); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local9); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg2); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local4 + 160))); + return local8; + } + + public static long[] call_1290(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1290(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1291(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 80)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + arg2 = ((int) callResult_0[0]); + local6 = (arg1 + 8); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + local7 = (arg1 + 16); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local8 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 72)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1197, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local4 + 64)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1198, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 96); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg0 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local8 = ((int) callResult_5[0]); + local9 = memory.readLong((int) local4 < 0 ? local4 : local4 + 64); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 72); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local8); + callArgs_6[0] = ((long) (local4 + 120)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local11 = ((int) callResult_6[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56876); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local11); + callArgs_7[0] = ((long) (arg0 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local11); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) local10); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 80, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56708); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg0); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local8); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local8 = 0; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg2); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local4 + 160))); + return local8; + } + + public static long[] call_1291(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1291(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1292(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 80)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + arg2 = ((int) callResult_0[0]); + local6 = (arg1 + 8); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + local7 = (arg1 + 16); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local8 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 72)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1197, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local4 + 64)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1198, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 96); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg0 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local8 = ((int) callResult_5[0]); + local9 = memory.readLong((int) local4 < 0 ? local4 : local4 + 64); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 72); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local8); + callArgs_6[0] = ((long) (local4 + 120)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local11 = ((int) callResult_6[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57060); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local11); + callArgs_7[0] = ((long) (arg0 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local11); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) local10); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 80, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56892); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg0); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local8); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local8 = 0; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg2); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local4 + 160))); + return local8; + } + + public static long[] call_1292(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1292(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1293(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + int local11 = 0; + local4 = (((int) instance.global(0).getValue()) - 160); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 + 80)); + long[] callResult_0 = instance.getMachine().call(154, callArgs_0); + arg2 = ((int) callResult_0[0]); + local6 = (arg1 + 8); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + local7 = (arg1 + 16); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local8 = 1; + label_1: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) local4); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1199, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (local4 + 72)); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1197, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local4 + 64)); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1198, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 96); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + arg0 = ((int) callResult_4[0]); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) arg2); + callArgs_5[0] = ((long) (local4 + 24)); + long[] callResult_5 = instance.getMachine().call(159, callArgs_5); + local8 = ((int) callResult_5[0]); + local9 = memory.readLong((int) local4 < 0 ? local4 : local4 + 64); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 72); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local8); + callArgs_6[0] = ((long) (local4 + 120)); + long[] callResult_6 = instance.getMachine().call(159, callArgs_6); + local11 = ((int) callResult_6[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57244); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local11); + callArgs_7[0] = ((long) (arg0 + 36)); + long[] callResult_7 = instance.getMachine().call(159, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local11); + long[] callResult_8 = instance.getMachine().call(162, callArgs_8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) local10); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 80, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57076); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg0); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) arg1); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local8); + long[] callResult_10 = instance.getMachine().call(162, callArgs_10); + local8 = 0; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) arg2); + long[] callResult_11 = instance.getMachine().call(162, callArgs_11); + instance.global(0).setValue(((long) (local4 + 160))); + return local8; + } + + public static long[] call_1293(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1293(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1294(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local3 = (((int) instance.global(0).getValue()) - 80); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(59, ((int) callResult_0[0])) != 0) { + break label_3; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(58, ((int) callResult_1[0])) != 0) { + break label_3; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 48); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + local4 = ((int) callResult_2[0]); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 33, (byte) (0)); + memory.writeByte((int) (local4 + 32) < 0 ? (local4 + 32) : (local4 + 32) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 30602) & 0xFF))); + memory.writeLong((int) (local4 + 24) < 0 ? (local4 + 24) : (local4 + 24) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 30594)); + memory.writeLong((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 30586)); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 30578)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 30570)); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 12); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + arg1 = ((int) callResult_3[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 64, (int) arg1); + local5 = (arg1 + 12); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 72, (int) local5); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 33); + callArgs_4[1] = ((long) local4); + callArgs_4[0] = ((long) arg1); + instance.getMachine().call(1647, callArgs_4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 68, (int) local5); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 0); + callArgs_5[1] = ((long) (local3 + 64)); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1163, callArgs_5); + local5 = ((int) callResult_5[0]); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11), -1) != 0) { + break label_4; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + instance.getMachine().call(1777, callArgs_6); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg1); + instance.getMachine().call(1777, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_8); + break label_2; + } + local5 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local4 = ((arg0 + 16) + (local5 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local5 ^ 1))); + local5 = 0; + memory.writeByte((int) local4 < 0 ? local4 : local4 + 36, (byte) (0)); + label_5: { + label_6: { + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 28); + local4 = memory.readInt((int) local4 < 0 ? local4 : local4 + 32); + long[] callArgs_9 = new long[4]; + callArgs_9[3] = ((long) 0); + callArgs_9[2] = ((long) arg2); + callArgs_9[1] = ((long) (local6 + local4)); + callArgs_9[0] = ((long) local6); + long[] callResult_9 = instance.getMachine().call(548, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_9[0])) != 0) { + break label_6; + } + memory.writeI32((int) ((local3 + 8) + 16) < 0 ? ((local3 + 8) + 16) : ((local3 + 8) + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) ((local3 + 8) + 8) < 0 ? ((local3 + 8) + 8) : ((local3 + 8) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 8, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local6); + long[] callArgs_10 = new long[4]; + callArgs_10[3] = ((long) local3); + callArgs_10[2] = ((long) 30799); + callArgs_10[1] = ((long) (local3 + 8)); + callArgs_10[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_10); + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0), 256L) != 0) { + break label_2; + } + memory.writeI32((int) ((local3 + 40) + 16) < 0 ? ((local3 + 40) + 16) : ((local3 + 40) + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) ((local3 + 40) + 8) < 0 ? ((local3 + 40) + 8) : ((local3 + 40) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 40, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 32, (int) local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 36, (int) local6); + long[] callArgs_11 = new long[4]; + callArgs_11[3] = ((long) (local3 + 32)); + callArgs_11[2] = ((long) 30531); + callArgs_11[1] = ((long) (local3 + 40)); + callArgs_11[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_11); + } + local5 = 1; + } + instance.global(0).setValue(((long) (local3 + 80))); + return local5; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1294(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1294(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1295(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + long local11 = 0L; + int local12 = 0; + local4 = (((int) instance.global(0).getValue()) - 256); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 144, (int) local5); + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + callArgs_0[0] = ((long) (local4 + 144)); + long[] callResult_0 = instance.getMachine().call(194, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + local6 = ((local4 + 152) + 16); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + local7 = ((local4 + 152) + 8); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 152, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local4 + 144)); + callArgs_1[0] = ((long) (local4 + 192)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) ((local4 + 64) + 8) < 0 ? ((local4 + 64) + 8) : ((local4 + 64) + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) ((local4 + 64) + 16) < 0 ? ((local4 + 64) + 16) : ((local4 + 64) + 16) + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 64, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 152)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 48, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 192)); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local4 + 48)); + callArgs_2[2] = ((long) 11125); + callArgs_2[1] = ((long) (local4 + 64)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_2); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg1); + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) (local4 + 152)); + long[] callResult_3 = instance.getMachine().call(155, callArgs_3); + arg2 = ((int) callResult_3[0]); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 15) & 0xFF)) != 0) { + break label_3; + } + label_4: { + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 0); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1154, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(59, ((int) callResult_4[0])) != 0) { + break label_4; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(133, ((int) callResult_5[0])) != 0) { + break label_4; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(131, ((int) callResult_6[0])) != 0) { + break label_4; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1154, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(59, ((int) callResult_7[0])) != 0) { + break label_3; + } + } + memory.writeI32((int) ((local4 + 24) + 16) < 0 ? ((local4 + 24) + 16) : ((local4 + 24) + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) ((local4 + 24) + 8) < 0 ? ((local4 + 24) + 8) : ((local4 + 24) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local6 = 1; + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) arg2); + callArgs_8[1] = ((long) (local4 + 24)); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1199, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_8[0])) != 0) { + break label_2; + } + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) (local4 + 144)); + callArgs_9[0] = ((long) arg0); + long[] callResult_9 = instance.getMachine().call(1197, callArgs_9); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) (local4 + 136)); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1198, callArgs_10); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 128, (long) 0L); + local7 = (arg1 + 8); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + local8 = (arg1 + 16); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local6 = 1; + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local4 + 128)); + callArgs_11[1] = ((long) local4); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1294, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + break label_2; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) 104); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + arg0 = ((int) callResult_12[0]); + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) arg2); + callArgs_13[0] = ((long) (local4 + 88)); + long[] callResult_13 = instance.getMachine().call(159, callArgs_13); + local6 = ((int) callResult_13[0]); + local9 = memory.readLong((int) local4 < 0 ? local4 : local4 + 136); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 144); + local11 = memory.readLong((int) local4 < 0 ? local4 : local4 + 128); + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) local6); + callArgs_14[0] = ((long) (local4 + 192)); + long[] callResult_14 = instance.getMachine().call(159, callArgs_14); + local12 = ((int) callResult_14[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 44); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57532); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) local12); + callArgs_15[0] = ((long) (arg0 + 36)); + long[] callResult_15 = instance.getMachine().call(159, callArgs_15); + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) local12); + long[] callResult_16 = instance.getMachine().call(162, callArgs_16); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 96, (long) local11); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) local10); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 80, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57376); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg0); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + int ciTableIdx_17 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_17 = instance.table(0).requiredRef(ciTableIdx_17); + com.dylibso.chicory.runtime.Instance ciRefInstance_17 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_17), instance); + if (!ciRefInstance_17.type(ciRefInstance_17.functionType(ciFuncId_17)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) arg1); + ciRefInstance_17.getMachine().call(ciFuncId_17, callArgs_17); + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) local6); + long[] callResult_18 = instance.getMachine().call(162, callArgs_18); + local6 = 0; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) arg2); + long[] callResult_19 = instance.getMachine().call(162, callArgs_19); + instance.global(0).setValue(((long) (local4 + 256))); + return local6; + } + + public static long[] call_1295(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1295(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1296(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + long local11 = 0L; + int local12 = 0; + local4 = (((int) instance.global(0).getValue()) - 256); + instance.global(0).setValue(((long) local4)); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 144, (int) local5); + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + callArgs_0[0] = ((long) (local4 + 144)); + long[] callResult_0 = instance.getMachine().call(194, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + local6 = ((local4 + 152) + 16); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + local7 = ((local4 + 152) + 8); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 152, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local4 + 144)); + callArgs_1[0] = ((long) (local4 + 192)); + instance.getMachine().call(192, callArgs_1); + memory.writeLong((int) ((local4 + 64) + 8) < 0 ? ((local4 + 64) + 8) : ((local4 + 64) + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) ((local4 + 64) + 16) < 0 ? ((local4 + 64) + 16) : ((local4 + 64) + 16) + 0, (int) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 64, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 152)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 48, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 192)); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) (local4 + 48)); + callArgs_2[2] = ((long) 11125); + callArgs_2[1] = ((long) (local4 + 64)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_2); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg1); + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) (local4 + 152)); + long[] callResult_3 = instance.getMachine().call(155, callArgs_3); + arg2 = ((int) callResult_3[0]); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) < 0 ? memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) : memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 15) & 0xFF)) != 0) { + break label_3; + } + label_4: { + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 0); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1154, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(59, ((int) callResult_4[0])) != 0) { + break label_4; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 1); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(133, ((int) callResult_5[0])) != 0) { + break label_4; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 1); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1154, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(131, ((int) callResult_6[0])) != 0) { + break label_4; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 1); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1154, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(59, ((int) callResult_7[0])) != 0) { + break label_3; + } + } + memory.writeI32((int) ((local4 + 24) + 16) < 0 ? ((local4 + 24) + 16) : ((local4 + 24) + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) ((local4 + 24) + 8) < 0 ? ((local4 + 24) + 8) : ((local4 + 24) + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local6 = 1; + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) arg2); + callArgs_8[1] = ((long) (local4 + 24)); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1199, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_8[0])) != 0) { + break label_2; + } + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) (local4 + 144)); + callArgs_9[0] = ((long) arg0); + long[] callResult_9 = instance.getMachine().call(1197, callArgs_9); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) (local4 + 136)); + callArgs_10[0] = ((long) arg0); + long[] callResult_10 = instance.getMachine().call(1198, callArgs_10); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 128, (long) 0L); + local7 = (arg1 + 8); + memory.writeLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + local8 = (arg1 + 16); + memory.writeI32((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + local6 = 1; + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (local4 + 128)); + callArgs_11[1] = ((long) local4); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1294, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + break label_2; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) 104); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + arg0 = ((int) callResult_12[0]); + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) arg2); + callArgs_13[0] = ((long) (local4 + 88)); + long[] callResult_13 = instance.getMachine().call(159, callArgs_13); + local6 = ((int) callResult_13[0]); + local9 = memory.readLong((int) local4 < 0 ? local4 : local4 + 136); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 144); + local11 = memory.readLong((int) local4 < 0 ? local4 : local4 + 128); + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) local6); + callArgs_14[0] = ((long) (local4 + 192)); + long[] callResult_14 = instance.getMachine().call(159, callArgs_14); + local12 = ((int) callResult_14[0]); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 45); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57704); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 12, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) (arg0 + 20) < 0 ? (arg0 + 20) : (arg0 + 20) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) (arg0 + 28) < 0 ? (arg0 + 28) : (arg0 + 28) + 0, (int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) local12); + callArgs_15[0] = ((long) (arg0 + 36)); + long[] callResult_15 = instance.getMachine().call(159, callArgs_15); + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) local12); + long[] callResult_16 = instance.getMachine().call(162, callArgs_16); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 96, (long) local11); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) local10); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 80, (long) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 72, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57548); + arg1 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) arg0); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + int ciTableIdx_17 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_17 = instance.table(0).requiredRef(ciTableIdx_17); + com.dylibso.chicory.runtime.Instance ciRefInstance_17 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_17), instance); + if (!ciRefInstance_17.type(ciRefInstance_17.functionType(ciFuncId_17)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) arg1); + ciRefInstance_17.getMachine().call(ciFuncId_17, callArgs_17); + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) local6); + long[] callResult_18 = instance.getMachine().call(162, callArgs_18); + local6 = 0; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) arg2); + long[] callResult_19 = instance.getMachine().call(162, callArgs_19); + instance.global(0).setValue(((long) (local4 + 256))); + return local6; + } + + public static long[] call_1296(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1296(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1297(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int _snap_0 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local2)); + label_1: { + local3 = (arg0 + 16); + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_1; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_0[0] = ((long) (local2 + 88)); + instance.getMachine().call(557, callArgs_0); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local5 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) * 40)); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0, (long) memory.readLong((int) ((local2 + 88) + 8) < 0 ? ((local2 + 88) + 8) : ((local2 + 88) + 8) + 0)); + memory.writeLong((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0, (long) memory.readLong((int) ((local2 + 88) + 16) < 0 ? ((local2 + 88) + 16) : ((local2 + 88) + 16) + 0)); + memory.writeLong((int) (local5 + 24) < 0 ? (local5 + 24) : (local5 + 24) + 0, (long) memory.readLong((int) ((local2 + 88) + 24) < 0 ? ((local2 + 88) + 24) : ((local2 + 88) + 24) + 0)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) memory.readInt((int) ((local2 + 88) + 32) < 0 ? ((local2 + 88) + 32) : ((local2 + 88) + 32) + 0)); + label_2: { + if (((int) memory.read((int) local5 < 0 ? local5 : local5 + 36) & 0xFF) != 0) { + break label_2; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local4 * 40)) < 0 ? (local3 + (local4 * 40)) : (local3 + (local4 * 40)) + 36) & 0xFF) != 0) { + break label_1; + } + local4 = (local4 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local4)); + } + label_3: { + local4 = (local3 + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local4 < 0 ? local4 : local4 + 36) & 0xFF)) != 0) { + break label_3; + } + memory.writeLong((int) ((local2 + 88) + 8) < 0 ? ((local2 + 88) + 8) : ((local2 + 88) + 8) + 0, (long) memory.readLong((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeI32((int) ((local2 + 88) + 16) < 0 ? ((local2 + 88) + 16) : ((local2 + 88) + 16) + 0, (int) memory.readInt((int) (local4 + 16) < 0 ? (local4 + 16) : (local4 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 88, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeI32((int) ((local2 + 72) + 8) < 0 ? ((local2 + 72) + 8) : ((local2 + 72) + 8) + 0, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 72, (long) 0L); + local4 = 1; + label_4: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local2 + 72)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1178, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_1[0])) != 0) { + break label_4; + } + local4 = 0; + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 83) & 0xFF); + _snap_0 = local3; + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local3); + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 76) : _snap_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_4; + } + local4 = 0; + label_5: { + local6 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 11) & 0xFF); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local6); + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0) != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4) : local6); + if (local8 != 0) { + break label_5; + } + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) ((local2 + 88) + 8) < 0 ? ((local2 + 88) + 8) : ((local2 + 88) + 8) + 0)); + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) ((local2 + 88) + 16) < 0 ? ((local2 + 88) + 16) : ((local2 + 88) + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 72) : (local2 + 72))); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local2); + callArgs_2[2] = ((long) 30877); + callArgs_2[1] = ((long) (local2 + 8)); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_2); + break label_4; + } + local9 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 0) != 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 72) : (local2 + 72)); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local8) != 0) { + break label_6; + } + local4 = 0; + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0) != 0) { + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_4; + } + local3 = local9; + local5 = arg1; + label_8: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF), ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) != 0) { + break label_6; + } + local3 = (local3 + 1); + local5 = (local5 + 1); + local6 = (local6 + -1); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_4; + } + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local5); + callArgs_3[1] = ((long) local9); + callArgs_3[0] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callResult_3 = instance.getMachine().call(1889, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_3[0])) != 0) { + break label_4; + } + } + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + memory.writeI32((int) ((local2 + 48) + 16) < 0 ? ((local2 + 48) + 16) : ((local2 + 48) + 16) + 0, (int) memory.readInt((int) ((local2 + 88) + 16) < 0 ? ((local2 + 88) + 16) : ((local2 + 88) + 16) + 0)); + memory.writeLong((int) ((local2 + 48) + 8) < 0 ? ((local2 + 48) + 8) : ((local2 + 48) + 8) + 0, (long) memory.readLong((int) ((local2 + 88) + 8) < 0 ? ((local2 + 88) + 8) : ((local2 + 88) + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 48, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) local9); + local4 = 0; + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0) != 0 ? local3 : arg1)); + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) (local2 + 32)); + callArgs_4[2] = ((long) 31007); + callArgs_4[1] = ((long) (local2 + 48)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_4); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 83), -1) != 0) { + break label_9; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 72)); + instance.getMachine().call(1777, callArgs_5); + } + instance.global(0).setValue(((long) (local2 + 128))); + return local4; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1297(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1297(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1298(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local2 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local2)); + local3 = (arg0 + 16); + local4 = (local2 + 88); + local5 = ((local2 + 32) + 20); + local6 = 0; + local7 = 0; + label_1: { + label_2: while (true) { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(76, (((int) callResult_0[0]) & -2)) != 0) { + break label_7; + } + label_8: { + local8 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + if (((int) memory.read((int) (local3 + (local8 * 40)) < 0 ? (local3 + (local8 * 40)) : (local3 + (local8 * 40)) + 36) & 0xFF) != 0) { + break label_8; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_1[0] = ((long) (local2 + 104)); + instance.getMachine().call(557, callArgs_1); + local8 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local9 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) * 40)); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeLong((int) (local9 + 8) < 0 ? (local9 + 8) : (local9 + 8) + 0, (long) memory.readLong((int) ((local2 + 104) + 8) < 0 ? ((local2 + 104) + 8) : ((local2 + 104) + 8) + 0)); + memory.writeLong((int) (local9 + 16) < 0 ? (local9 + 16) : (local9 + 16) + 0, (long) memory.readLong((int) ((local2 + 104) + 16) < 0 ? ((local2 + 104) + 16) : ((local2 + 104) + 16) + 0)); + memory.writeLong((int) (local9 + 24) < 0 ? (local9 + 24) : (local9 + 24) + 0, (long) memory.readLong((int) ((local2 + 104) + 24) < 0 ? ((local2 + 104) + 24) : ((local2 + 104) + 24) + 0)); + memory.writeI32((int) (local9 + 32) < 0 ? (local9 + 32) : (local9 + 32) + 0, (int) memory.readInt((int) ((local2 + 104) + 32) < 0 ? ((local2 + 104) + 32) : ((local2 + 104) + 32) + 0)); + label_9: { + if (((int) memory.read((int) local9 < 0 ? local9 : local9 + 36) & 0xFF) != 0) { + break label_9; + } + memory.writeByte((int) local9 < 0 ? local9 : local9 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local3 + (local8 * 40)) < 0 ? (local3 + (local8 * 40)) : (local3 + (local8 * 40)) + 36) & 0xFF) != 0) { + break label_8; + } + local8 = (local8 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (local8)); + } + local8 = (local3 + (local8 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF)) != 0) { + break label_6; + } + local10 = ((local2 + 32) + 8); + memory.writeLong((int) local10 < 0 ? local10 : local10 + 0, (long) memory.readLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0)); + local11 = ((local2 + 32) + 16); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) memory.readInt((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 32, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(154, callArgs_2); + local12 = ((int) callResult_2[0]); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 88, (long) 0L); + local9 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local8 = (local3 + (local9 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF)) != 0) { + break label_6; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local9 ^ 1))); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 36, (byte) (0)); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(76, memory.readInt((int) local8 < 0 ? local8 : local8 + 20)) != 0) { + break label_10; + } + local13 = 0; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local12); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1166, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_3[0])) != 0) { + break label_4; + } + break label_5; + } + local9 = (local6 & 1); + local6 = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_5; + } + memory.writeI32((int) ((local2 + 8) + 16) < 0 ? ((local2 + 8) + 16) : ((local2 + 8) + 16) + 0, (int) memory.readInt((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0)); + memory.writeLong((int) ((local2 + 8) + 8) < 0 ? ((local2 + 8) + 8) : ((local2 + 8) + 8) + 0, (long) memory.readLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0)); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 8, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + local13 = 0; + long[] callArgs_4 = new long[4]; + callArgs_4[3] = ((long) 0); + callArgs_4[2] = ((long) 18326); + callArgs_4[1] = ((long) (local2 + 8)); + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_4); + local6 = 1; + break label_4; + } + local8 = 0; + if ((local7 & 1) != 0) { + break label_1; + } + memory.writeByte((int) local2 < 0 ? local2 : local2 + 115, (byte) (5)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 104, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 14289)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 108, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 14293) & 0xFF))); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 109, (byte) (0)); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 12); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + local9 = ((int) callResult_5[0]); + memory.writeLong((int) local9 < 0 ? local9 : local9 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 104)); + memory.writeI32((int) (local9 + 8) < 0 ? (local9 + 8) : (local9 + 8) + 0, (int) memory.readInt((int) ((local2 + 104) + 8) < 0 ? ((local2 + 104) + 8) : ((local2 + 104) + 8) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 32, (int) local9); + local8 = (local9 + 12); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) local8); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 36, (int) local8); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 0); + callArgs_6[1] = ((long) (local2 + 32)); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1163, callArgs_6); + local8 = ((int) callResult_6[0]); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local9 < 0 ? local9 : local9 + 11), -1) != 0) { + break label_11; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local9 < 0 ? local9 : local9 + 0)); + instance.getMachine().call(1777, callArgs_7); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local9); + instance.getMachine().call(1777, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local2 < 0 ? local2 : local2 + 115), -1) != 0) { + break label_1; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 104)); + instance.getMachine().call(1777, callArgs_9); + break label_1; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local13 = 0; + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) local4); + callArgs_11[0] = ((long) arg0); + long[] callResult_11 = instance.getMachine().call(1175, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + break label_4; + } + label_12: { + local8 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)) != 0) { + break label_12; + } + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 32)); + memory.writeI32((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0, (int) memory.readInt((int) local11 < 0 ? local11 : local11 + 0)); + memory.writeLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (long) memory.readLong((int) local10 < 0 ? local10 : local10 + 0)); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) local12); + callArgs_12[0] = ((long) (local8 + 20)); + long[] callResult_12 = instance.getMachine().call(157, callArgs_12); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) (local8 + 68)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 56, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 88)); + memory.writeI32((int) (local8 + 64) < 0 ? (local8 + 64) : (local8 + 64) + 0, (int) memory.readInt((int) local2 < 0 ? local2 : local2 + 96)); + local7 = 1; + local13 = 1; + break label_3; + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) (local2 + 32)); + callArgs_13[0] = ((long) arg1); + instance.getMachine().call(1303, callArgs_13); + local13 = 1; + local7 = 1; + } + local8 = memory.readInt((int) local2 < 0 ? local2 : local2 + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_3; + } + label_13: while (true) { + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 4); + int ciTableIdx_14 = (int) (memory.readInt((int) memory.readInt((int) local8 < 0 ? local8 : local8 + 0) < 0 ? memory.readInt((int) local8 < 0 ? local8 : local8 + 0) : memory.readInt((int) local8 < 0 ? local8 : local8 + 0) + 4)); + int ciFuncId_14 = instance.table(0).requiredRef(ciTableIdx_14); + com.dylibso.chicory.runtime.Instance ciRefInstance_14 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_14), instance); + if (!ciRefInstance_14.type(ciRefInstance_14.functionType(ciFuncId_14)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local8); + ciRefInstance_14.getMachine().call(ciFuncId_14, callArgs_14); + local8 = local9; + if (local9 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break; + } + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 96, (int) 0); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 88, (long) 0L); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local12); + long[] callResult_15 = instance.getMachine().call(162, callArgs_15); + if (local13 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + local8 = 1; + } + instance.global(0).setValue(((long) (local2 + 144))); + return local8; + } + + public static long[] call_1298(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1298(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1299(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + label_3: while (true) { + label_4: { + local4 = (local3 + -68); + local5 = (local4 + 56); + local2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_4; + } + label_5: while (true) { + local6 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local2); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local2 = local6; + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + memory.writeLong((int) (local3 + -8) < 0 ? (local3 + -8) : (local3 + -8) + 0, (long) 0L); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + -48)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + local3 = local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + } + return arg0; + } + + public static long[] call_1299(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1299(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1300(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, arg2) != 0) { + break label_3; + } + arg2 = 2; + label_4: { + label_5: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + switch((((int) callResult_0[0]) + -34)) { + case 0: + { + break label_4; + } + case 1: + { + break label_5; + } + default: + { + break label_3; + } + } + } + arg2 = 1; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local5 = ((arg0 + (local4 * 40)) + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) != 0) { + break label_1; + } + local6 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 52, (int) arg2); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 36, (long) 0L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -4L); + break label_2; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + arg2 = ((arg0 + 16) + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 36) & 0xFF)) != 0) { + break label_1; + } + local6 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 36, (byte) (0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 20) + -57), 2) != 0) { + break label_2; + } + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 28); + arg0 = (int) local7; + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 8)); + callArgs_1[2] = ((long) (arg0 + (int) (local7 >>> 32L))); + callArgs_1[1] = ((long) arg0); + callArgs_1[0] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + long[] callResult_1 = instance.getMachine().call(554, callArgs_1); + local6 = ((int) callResult_1[0]); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 52, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -4L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 36, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 8)); + } + instance.global(0).setValue(((long) (local3 + 16))); + return local6; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1300(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1300(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1301(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + long local9 = 0L; + long local10 = 0L; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + local4 = (((int) instance.global(0).getValue()) - 256); + instance.global(0).setValue(((long) local4)); + local5 = 1; + local6 = 16; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + switch((arg2 + -51)) { + case 0: + { + break label_2; + } + case 1: + { + break label_3; + } + case 2: + { + break label_8; + } + case 3: + { + break label_7; + } + case 4: + { + break label_6; + } + case 5: + { + break label_5; + } + default: + { + break label_4; + } + } + } + local6 = 4; + break label_2; + } + local6 = 2; + break label_2; + } + local6 = 4; + local5 = 0; + break label_2; + } + local6 = 2; + local5 = 0; + break label_2; + } + local7 = ((local4 + 232) + 16); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + local8 = ((local4 + 232) + 8); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 232, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg2); + long[] callResult_0 = instance.getMachine().call(538, callArgs_0); + arg2 = ((int) callResult_0[0]); + memory.writeI32((int) ((local4 + 8) + 16) < 0 ? ((local4 + 8) + 16) : ((local4 + 8) + 16) + 0, (int) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) ((local4 + 8) + 8) < 0 ? ((local4 + 8) + 8) : ((local4 + 8) + 8) + 0, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg2); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 232)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local4); + callArgs_1[2] = ((long) 29211); + callArgs_1[1] = ((long) (local4 + 8)); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_1); + arg2 = 1; + break label_1; + } + local6 = 8; + } + label_9: { + label_10: { + local7 = (arg0 + 16); + arg2 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local8 = (local7 + (arg2 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF)) != 0) { + break label_10; + } + memory.writeByte((int) (local8 + 36) < 0 ? (local8 + 36) : (local8 + 36) + 0, (byte) (0)); + arg2 = (arg2 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (arg2)); + label_11: { + if (((int) memory.read((int) (local7 + (arg2 * 40)) < 0 ? (local7 + (arg2 * 40)) : (local7 + (arg2 * 40)) + 36) & 0xFF) != 0) { + break label_11; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_2[0] = ((long) (local4 + 96)); + instance.getMachine().call(557, callArgs_2); + arg2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local8 = (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) * 40)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 96)); + memory.writeLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (long) memory.readLong((int) ((local4 + 96) + 8) < 0 ? ((local4 + 96) + 8) : ((local4 + 96) + 8) + 0)); + memory.writeLong((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0, (long) memory.readLong((int) ((local4 + 96) + 16) < 0 ? ((local4 + 96) + 16) : ((local4 + 96) + 16) + 0)); + memory.writeLong((int) (local8 + 24) < 0 ? (local8 + 24) : (local8 + 24) + 0, (long) memory.readLong((int) ((local4 + 96) + 24) < 0 ? ((local4 + 96) + 24) : ((local4 + 96) + 24) + 0)); + memory.writeI32((int) (local8 + 32) < 0 ? (local8 + 32) : (local8 + 32) + 0, (int) memory.readInt((int) ((local4 + 96) + 32) < 0 ? ((local4 + 96) + 32) : ((local4 + 96) + 32) + 0)); + label_12: { + if (((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF) != 0) { + break label_12; + } + memory.writeByte((int) local8 < 0 ? local8 : local8 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local7 + (arg2 * 40)) < 0 ? (local7 + (arg2 * 40)) : (local7 + (arg2 * 40)) + 36) & 0xFF) != 0) { + break label_11; + } + arg2 = (arg2 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (arg2)); + } + arg2 = (local7 + (arg2 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 36) & 0xFF)) != 0) { + break label_10; + } + local9 = memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0); + local10 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0, (int) memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + memory.writeLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0, (long) local9); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local10); + local11 = (arg1 + 52); + local12 = (local6 + -2); + local13 = (local12 >>> 1); + local14 = 36; + local15 = 36; + local16 = 0; + label_13: while (true) { + label_14: { + arg2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + if (((int) memory.read((int) (local7 + (arg2 * 40)) < 0 ? (local7 + (arg2 * 40)) : (local7 + (arg2 * 40)) + 36) & 0xFF) != 0) { + break label_14; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_3[0] = ((long) (local4 + 96)); + instance.getMachine().call(557, callArgs_3); + arg2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local8 = (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) * 40)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 96)); + memory.writeLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (long) memory.readLong((int) ((local4 + 96) + 8) < 0 ? ((local4 + 96) + 8) : ((local4 + 96) + 8) + 0)); + memory.writeLong((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0, (long) memory.readLong((int) ((local4 + 96) + 16) < 0 ? ((local4 + 96) + 16) : ((local4 + 96) + 16) + 0)); + memory.writeLong((int) (local8 + 24) < 0 ? (local8 + 24) : (local8 + 24) + 0, (long) memory.readLong((int) ((local4 + 96) + 24) < 0 ? ((local4 + 96) + 24) : ((local4 + 96) + 24) + 0)); + memory.writeI32((int) (local8 + 32) < 0 ? (local8 + 32) : (local8 + 32) + 0, (int) memory.readInt((int) ((local4 + 96) + 32) < 0 ? ((local4 + 96) + 32) : ((local4 + 96) + 32) + 0)); + label_15: { + if (((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF) != 0) { + break label_15; + } + memory.writeByte((int) local8 < 0 ? local8 : local8 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local7 + (arg2 * 40)) < 0 ? (local7 + (arg2 * 40)) : (local7 + (arg2 * 40)) + 36) & 0xFF) != 0) { + break label_14; + } + arg2 = (arg2 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (arg2)); + } + local8 = (local7 + (arg2 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF)) != 0) { + break label_10; + } + memory.writeLong((int) ((local4 + 208) + 8) < 0 ? ((local4 + 208) + 8) : ((local4 + 208) + 8) + 0, (long) memory.readLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0)); + memory.writeI32((int) ((local4 + 208) + 16) < 0 ? ((local4 + 208) + 16) : ((local4 + 208) + 16) + 0, (int) memory.readInt((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 208, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + label_16: { + if (((int) memory.read((int) (local7 + (arg2 * 40)) < 0 ? (local7 + (arg2 * 40)) : (local7 + (arg2 * 40)) + 36) & 0xFF) != 0) { + break label_16; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + callArgs_4[0] = ((long) (local4 + 96)); + instance.getMachine().call(557, callArgs_4); + arg2 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 96) & 0xFF); + local8 = (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) * 40)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 96)); + memory.writeLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0, (long) memory.readLong((int) ((local4 + 96) + 8) < 0 ? ((local4 + 96) + 8) : ((local4 + 96) + 8) + 0)); + memory.writeLong((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0, (long) memory.readLong((int) ((local4 + 96) + 16) < 0 ? ((local4 + 96) + 16) : ((local4 + 96) + 16) + 0)); + memory.writeLong((int) (local8 + 24) < 0 ? (local8 + 24) : (local8 + 24) + 0, (long) memory.readLong((int) ((local4 + 96) + 24) < 0 ? ((local4 + 96) + 24) : ((local4 + 96) + 24) + 0)); + memory.writeI32((int) (local8 + 32) < 0 ? (local8 + 32) : (local8 + 32) + 0, (int) memory.readInt((int) ((local4 + 96) + 32) < 0 ? ((local4 + 96) + 32) : ((local4 + 96) + 32) + 0)); + label_17: { + if (((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF) != 0) { + break label_17; + } + memory.writeByte((int) local8 < 0 ? local8 : local8 + 36, (byte) (1)); + } + if (((int) memory.read((int) (local7 + (arg2 * 40)) < 0 ? (local7 + (arg2 * 40)) : (local7 + (arg2 * 40)) + 36) & 0xFF) != 0) { + break label_16; + } + arg2 = (arg2 ^ 1); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) (arg2)); + } + local8 = (local7 + (arg2 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF)) != 0) { + break label_10; + } + memory.writeLong((int) ((local4 + 168) + 16) < 0 ? ((local4 + 168) + 16) : ((local4 + 168) + 16) + 0, (long) memory.readLong((int) (local8 + 16) < 0 ? (local8 + 16) : (local8 + 16) + 0)); + memory.writeI32((int) ((local4 + 168) + 32) < 0 ? ((local4 + 168) + 32) : ((local4 + 168) + 32) + 0, (int) memory.readInt((int) (local8 + 32) < 0 ? (local8 + 32) : (local8 + 32) + 0)); + memory.writeLong((int) ((local4 + 168) + 24) < 0 ? ((local4 + 168) + 24) : ((local4 + 168) + 24) + 0, (long) memory.readLong((int) (local8 + 24) < 0 ? (local8 + 24) : (local8 + 24) + 0)); + memory.writeLong((int) ((local4 + 168) + 8) < 0 ? ((local4 + 168) + 8) : ((local4 + 168) + 8) + 0, (long) memory.readLong((int) (local8 + 8) < 0 ? (local8 + 8) : (local8 + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 168, (long) memory.readLong((int) local8 < 0 ? local8 : local8 + 0)); + label_18: { + label_19: { + label_20: { + label_21: { + label_22: { + label_23: { + local8 = (memory.readInt((int) local4 < 0 ? local4 : local4 + 188) + -34); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, 25) != 0) { + break label_23; + } + local8 = (1 << local8); + if ((local8 & 8388611) != 0) { + break label_21; + } + if ((local8 & 50331648) != 0) { + break label_22; + } + } + if (local5 != 0) { + break label_9; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 16); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + local8 = ((int) callResult_5[0]); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 15, (byte) (0)); + memory.writeLong((int) (local8 + 7) < 0 ? (local8 + 7) : (local8 + 7) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 13461)); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 13454)); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) 12); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + local7 = ((int) callResult_6[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 96, (int) local7); + arg2 = (local7 + 12); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 104, (int) arg2); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 15); + callArgs_7[1] = ((long) local8); + callArgs_7[0] = ((long) local7); + instance.getMachine().call(1647, callArgs_7); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 100, (int) arg2); + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 28536); + callArgs_8[1] = ((long) (local4 + 96)); + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1163, callArgs_8); + arg2 = ((int) callResult_8[0]); + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local7 < 0 ? local7 : local7 + 11), -1) != 0) { + break label_24; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) local7 < 0 ? local7 : local7 + 0)); + instance.getMachine().call(1777, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_10); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local8); + instance.getMachine().call(1777, callArgs_11); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_20; + } + local8 = (local7 + (arg2 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local8 < 0 ? local8 : local8 + 36) & 0xFF)) != 0) { + break label_10; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((arg2 ^ 1))); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 36, (byte) (0)); + local9 = memory.readLong((int) local8 < 0 ? local8 : local8 + 28); + label_25: { + label_26: { + label_27: { + label_28: { + switch(local13) { + case 0: + { + break label_25; + } + case 1: + { + break label_26; + } + case 2: + { + break label_18; + } + case 3: + { + break label_27; + } + case 4: + { + break label_18; + } + case 5: + { + break label_18; + } + case 6: + { + break label_18; + } + case 7: + { + break label_28; + } + default: + { + break label_18; + } + } + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 96, (byte) (0)); + arg2 = (int) local9; + long[] callArgs_12 = new long[4]; + callArgs_12[3] = ((long) 1); + callArgs_12[2] = ((long) (local4 + 96)); + callArgs_12[1] = ((long) (arg2 + (int) (local9 >>> 32L))); + callArgs_12[0] = ((long) arg2); + long[] callResult_12 = instance.getMachine().call(549, callArgs_12); + arg2 = ((int) callResult_12[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 28, (long) -6L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -5L); + memory.writeByte((int) ((arg1 + local16) + 36) < 0 ? ((arg1 + local16) + 36) : ((arg1 + local16) + 36) + 0, (byte) (((int) memory.read((int) local4 < 0 ? local4 : local4 + 96) & 0xFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local16, 3) != 0) { + break label_19; + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) 0); + break label_19; + } + memory.writeShort((int) local4 < 0 ? local4 : local4 + 96, (short) (0)); + arg2 = (int) local9; + long[] callArgs_13 = new long[4]; + callArgs_13[3] = ((long) 1); + callArgs_13[2] = ((long) (local4 + 96)); + callArgs_13[1] = ((long) (arg2 + (int) (local9 >>> 32L))); + callArgs_13[0] = ((long) arg2); + long[] callResult_13 = instance.getMachine().call(550, callArgs_13); + arg2 = ((int) callResult_13[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 28, (long) -7L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -5L); + memory.writeShort((int) (arg1 + local15) < 0 ? (arg1 + local15) : (arg1 + local15) + 0, (short) (((int) memory.readShort((int) local4 < 0 ? local4 : local4 + 96) & 0xFFFF))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local16, 3) != 0) { + break label_19; + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) 0); + break label_19; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 96, (int) 0); + arg2 = (int) local9; + long[] callArgs_14 = new long[4]; + callArgs_14[3] = ((long) 1); + callArgs_14[2] = ((long) (local4 + 96)); + callArgs_14[1] = ((long) (arg2 + (int) (local9 >>> 32L))); + callArgs_14[0] = ((long) arg2); + long[] callResult_14 = instance.getMachine().call(551, callArgs_14); + arg2 = ((int) callResult_14[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 28, (long) -1L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -5L); + memory.writeI32((int) (local11 + -16) < 0 ? (local11 + -16) : (local11 + -16) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 96)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local16, 3) != 0) { + break label_19; + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) 0); + break label_19; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 96, (long) 0L); + arg2 = (int) local9; + long[] callArgs_15 = new long[4]; + callArgs_15[3] = ((long) 1); + callArgs_15[2] = ((long) (local4 + 96)); + callArgs_15[1] = ((long) (arg2 + (int) (local9 >>> 32L))); + callArgs_15[0] = ((long) arg2); + long[] callResult_15 = instance.getMachine().call(548, callArgs_15); + arg2 = ((int) callResult_15[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 28, (long) -2L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -5L); + memory.writeLong((int) (arg1 + local14) < 0 ? (arg1 + local14) : (arg1 + local14) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 96)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local16, 3) != 0) { + break label_19; + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) 0); + break label_19; + } + if (local5 != 0) { + break label_9; + } + } + memory.writeI32((int) ((local4 + 96) + 16) < 0 ? ((local4 + 96) + 16) : ((local4 + 96) + 16) + 0, (int) 0); + memory.writeLong((int) ((local4 + 96) + 8) < 0 ? ((local4 + 96) + 8) : ((local4 + 96) + 8) + 0, (long) 0L); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 96, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 148, (int) 0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 132, (int) 0); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 116, (long) -1L); + label_29: { + label_30: { + label_31: { + label_32: { + label_33: { + switch(local12) { + case 0: + { + break label_32; + } + case 1: + { + break label_30; + } + case 2: + { + break label_33; + } + default: + { + break label_30; + } + } + } + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) arg3); + callArgs_16[1] = ((long) (local4 + 96)); + callArgs_16[0] = ((long) arg0); + long[] callResult_16 = instance.getMachine().call(1302, callArgs_16); + arg2 = ((int) callResult_16[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 28, (long) -3L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -5L); + memory.writeI32((int) (local11 + -16) < 0 ? (local11 + -16) : (local11 + -16) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 132)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local16, 4) != 0) { + break label_31; + } + break label_19; + } + long[] callArgs_17 = new long[3]; + callArgs_17[2] = ((long) arg3); + callArgs_17[1] = ((long) (local4 + 96)); + callArgs_17[0] = ((long) arg0); + long[] callResult_17 = instance.getMachine().call(1300, callArgs_17); + arg2 = ((int) callResult_17[0]); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 28, (long) -4L); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -5L); + memory.writeLong((int) (arg1 + local14) < 0 ? (arg1 + local14) : (arg1 + local14) + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 132)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local16, 3) != 0) { + break label_19; + } + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) 0); + local8 = memory.readInt((int) local4 < 0 ? local4 : local4 + 148); + break label_29; + } + local8 = 0; + arg2 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local16, 3) != 0) { + break label_19; + } + } + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) local8); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, arg2) != 0) { + break label_18; + } + arg2 = ((local4 + 72) + 16); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) memory.readInt((int) ((local4 + 208) + 16) < 0 ? ((local4 + 208) + 16) : ((local4 + 208) + 16) + 0)); + local7 = ((local4 + 72) + 8); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) ((local4 + 208) + 8) < 0 ? ((local4 + 208) + 8) : ((local4 + 208) + 8) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 72, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 208)); + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) (local4 + 168)); + callArgs_18[0] = ((long) (local4 + 96)); + instance.getMachine().call(544, callArgs_18); + memory.writeLong((int) ((local4 + 48) + 8) < 0 ? ((local4 + 48) + 8) : ((local4 + 48) + 8) + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeI32((int) ((local4 + 48) + 16) < 0 ? ((local4 + 48) + 16) : ((local4 + 48) + 16) + 0, (int) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 48, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 72)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 107), 0) != 0 ? memory.readInt((int) local4 < 0 ? local4 : local4 + 96) : (local4 + 96))); + long[] callArgs_19 = new long[4]; + callArgs_19[3] = ((long) (local4 + 32)); + callArgs_19[2] = ((long) 30899); + callArgs_19[1] = ((long) (local4 + 48)); + callArgs_19[0] = ((long) arg0); + instance.getMachine().call(1151, callArgs_19); + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local4 < 0 ? local4 : local4 + 107), -1) != 0) { + break label_34; + } + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) memory.readInt((int) local4 < 0 ? local4 : local4 + 96)); + instance.getMachine().call(1777, callArgs_20); + } + arg2 = 1; + break label_1; + } + local14 = (local14 + 8); + local15 = (local15 + 2); + local11 = (local11 + 4); + local16 = (local16 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local16, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break; + } + arg2 = 0; + break label_1; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) 32); + long[] callResult_22 = instance.getMachine().call(1776, callArgs_22); + local7 = ((int) callResult_22[0]); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 24, (byte) (0)); + memory.writeLong((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 13486)); + memory.writeLong((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 13478)); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 13470)); + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) 12); + long[] callResult_23 = instance.getMachine().call(1776, callArgs_23); + local8 = ((int) callResult_23[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 96, (int) local8); + arg2 = (local8 + 12); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 104, (int) arg2); + long[] callArgs_24 = new long[3]; + callArgs_24[2] = ((long) 24); + callArgs_24[1] = ((long) local7); + callArgs_24[0] = ((long) local8); + instance.getMachine().call(1647, callArgs_24); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 100, (int) arg2); + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) 28097); + callArgs_25[1] = ((long) (local4 + 96)); + callArgs_25[0] = ((long) arg0); + long[] callResult_25 = instance.getMachine().call(1163, callArgs_25); + arg2 = ((int) callResult_25[0]); + label_35: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local8 < 0 ? local8 : local8 + 11), -1) != 0) { + break label_35; + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) memory.readInt((int) local8 < 0 ? local8 : local8 + 0)); + instance.getMachine().call(1777, callArgs_26); + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) local8); + instance.getMachine().call(1777, callArgs_27); + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_28); + } + instance.global(0).setValue(((long) (local4 + 256))); + return arg2; + } + + public static long[] call_1301(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1301(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1302(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + long local7 = 0L; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, arg2) != 0) { + break label_3; + } + arg2 = 2; + label_4: { + label_5: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1154, callArgs_0); + switch((((int) callResult_0[0]) + -34)) { + case 0: + { + break label_4; + } + case 1: + { + break label_5; + } + default: + { + break label_3; + } + } + } + arg2 = 1; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + local5 = ((arg0 + (local4 * 40)) + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF)) != 0) { + break label_1; + } + local6 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (0)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 52, (int) arg2); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -3L); + break label_2; + } + local4 = ((int) memory.read((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0) & 0xFF); + arg2 = ((arg0 + 16) + (local4 * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 36) & 0xFF)) != 0) { + break label_1; + } + local6 = 1; + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 96, (byte) ((local4 ^ 1))); + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 36, (byte) (0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 20) + -57), 2) != 0) { + break label_2; + } + local7 = memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 28); + arg0 = (int) local7; + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) (local3 + 12)); + callArgs_1[2] = ((long) (arg0 + (int) (local7 >>> 32L))); + callArgs_1[1] = ((long) arg0); + callArgs_1[0] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 24)); + long[] callResult_1 = instance.getMachine().call(552, callArgs_1); + local6 = ((int) callResult_1[0]); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 52, (int) 0); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 20, (long) -3L); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 36, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 12)); + } + instance.global(0).setValue(((long) (local3 + 16))); + return local6; + } + instance.getMachine().call(1152, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1302(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1302(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1303(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + int local9 = 0; + int local10 = 0; + int local11 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2), 68); + local4 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 63161284) != 0) { + break label_4; + } + local5 = 0; + label_5: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 68); + local6 = (local2 << 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 31580641) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local4) != 0 ? local6 : local4) : 63161283); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 63161284) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 * 68)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local5 = ((int) callResult_0[0]); + } + local7 = (local5 + (local3 * 68)); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local7 + 16) < 0 ? (local7 + 16) : (local7 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (local7 + 8) < 0 ? (local7 + 8) : (local7 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 20)); + callArgs_1[0] = ((long) (local7 + 20)); + long[] callResult_1 = instance.getMachine().call(157, callArgs_1); + local8 = memory.readLong((int) (arg1 + 60) < 0 ? (arg1 + 60) : (arg1 + 60) + 0); + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 56); + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 56, (long) 0L); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 56, (int) local2); + memory.writeI32((int) (arg1 + 64) < 0 ? (arg1 + 64) : (arg1 + 64) + 0, (int) 0); + memory.writeLong((int) (local7 + 60) < 0 ? (local7 + 60) : (local7 + 60) + 0, (long) local8); + local9 = (local5 + (local4 * 68)); + local10 = (local7 + 68); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local11 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local11, local6) != 0) { + break label_2; + } + local5 = 0; + label_6: while (true) { + local4 = (local7 + local5); + local2 = (local4 + -68); + arg1 = (local6 + local5); + local3 = (arg1 + -68); + memory.writeLong((int) local2 < 0 ? local2 : local2 + 0, (long) memory.readLong((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) (local2 + 16) < 0 ? (local2 + 16) : (local2 + 16) + 0, (int) memory.readInt((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0)); + memory.writeLong((int) (local2 + 8) < 0 ? (local2 + 8) : (local2 + 8) + 0, (long) memory.readLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + -48)); + callArgs_2[0] = ((long) (local4 + -48)); + long[] callResult_2 = instance.getMachine().call(157, callArgs_2); + local2 = (arg1 + -12); + memory.writeLong((int) (local4 + -12) < 0 ? (local4 + -12) : (local4 + -12) + 0, (long) memory.readLong((int) local2 < 0 ? local2 : local2 + 0)); + memory.writeI32((int) (local4 + -4) < 0 ? (local4 + -4) : (local4 + -4) + 0, (int) memory.readInt((int) (arg1 + -4) < 0 ? (arg1 + -4) : (arg1 + -4) + 0)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) 0); + memory.writeLong((int) (arg1 + -8) < 0 ? (arg1 + -8) : (arg1 + -8) + 0, (long) 0L); + local5 = (local5 + -68); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local11, (local6 + local5)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local9); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local10); + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local7 + local5)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4) != 0) { + break label_1; + } + label_7: while (true) { + label_8: { + local2 = (local4 + -68); + local3 = (local2 + 56); + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_8; + } + label_9: while (true) { + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) < 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) : memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + 4)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg1); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + arg1 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeLong((int) (local4 + -8) < 0 ? (local4 + -8) : (local4 + -8) + 0, (long) 0L); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) (local4 + -48)); + long[] callResult_4 = instance.getMachine().call(162, callArgs_4); + local4 = local2; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local9); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local10); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local7); + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_10; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local6); + instance.getMachine().call(1777, callArgs_7); + } + return; + } + + public static long[] call_1303(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1303(arg0, arg1, memory, instance); + return null; + } + + public static void func_1304(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + label_2: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + local4 = (local3 & 3); + local5 = 0; + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 4) != 0) { + break label_3; + } + local6 = (local3 & -4); + local3 = 8; + local5 = 0; + label_4: while (true) { + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) + 0, (int) 0); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) + 0, (int) 0); + local3 = (local3 + 16); + local5 = (local5 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_5; + } + local3 = (local5 << 2); + label_6: while (true) { + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 0, (int) 0); + local3 = (local3 + 4); + local4 = (local4 + -1); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 8, (long) 0L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + label_7: while (true) { + local3 = local4; + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, arg1) != 0) { + break label_8; + } + label_9: while (true) { + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 23), -1) != 0) { + break label_10; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0)); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + local3 = arg1; + if (arg1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break label_1; + } + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local3) != 0) { + break label_11; + } + local5 = (arg1 + 12); + local4 = (local3 + 12); + local7 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 23) & 0xFF); + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(local7); + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 23), 0) != 0) { + break label_12; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0) { + break label_13; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + break label_11; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + callArgs_2[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12)); + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(1659, callArgs_2); + break label_11; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) (local6 != 0 ? memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0) : local7)); + callArgs_3[1] = ((long) (local6 != 0 ? memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12) : local5)); + callArgs_3[0] = ((long) local4); + long[] callResult_3 = instance.getMachine().call(1658, callArgs_3); + } + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local3); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1407, callArgs_4); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg1) != 0) { + break label_1; + } + label_14: while (true) { + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 24); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + local3 = ((int) callResult_5[0]); + local5 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local5); + local4 = (local3 + 12); + label_15: { + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 23), 0) != 0) { + break label_16; + } + local6 = (arg1 + 12); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local6 < 0 ? local6 : local6 + 0)); + memory.writeI32((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0, (int) memory.readInt((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0)); + break label_15; + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + callArgs_6[1] = ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12)); + callArgs_6[0] = ((long) local4); + instance.getMachine().call(1647, callArgs_6); + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) 0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local5); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local3); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1407, callArgs_7); + arg1 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, arg1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + } + return; + } + + public static long[] call_1304(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1304(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1305(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + label_1: { + local1 = memory.readInt((int) (arg0 + 52) < 0 ? (arg0 + 52) : (arg0 + 52) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 23), -1) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) (local1 + 12) < 0 ? (local1 + 12) : (local1 + 12) + 0)); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_1); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 44); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 44, (int) 0); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_4; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_2); + } + label_5: { + local1 = memory.readInt((int) (arg0 + 32) < 0 ? (arg0 + 32) : (arg0 + 32) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_5; + } + label_6: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 23), -1) != 0) { + break label_7; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) (local1 + 12) < 0 ? (local1 + 12) : (local1 + 12) + 0)); + instance.getMachine().call(1777, callArgs_3); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_4); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) 0); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_8; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_5); + } + label_9: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_9; + } + memory.writeI32((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0, (int) local1); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_6); + } + label_10: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_10; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local1); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_7); + } + return arg0; + } + + public static long[] call_1305(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1305(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1306(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local2), 96); + local4 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 44739243) != 0) { + break label_4; + } + label_5: { + label_6: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local2), 96); + local5 = (local2 << 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, 22369621) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, local4) != 0 ? local5 : local4) : 44739242); + if (local4 != 0) { + break label_6; + } + local2 = 0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 44739243) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 * 96)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + } + local6 = (local2 + (local3 * 96)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) (local6 + 16) < 0 ? (local6 + 16) : (local6 + 16) + 0, (int) memory.readInt((int) (arg1 + 16) < 0 ? (arg1 + 16) : (arg1 + 16) + 0)); + memory.writeLong((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (long) memory.readLong((int) (arg1 + 8) < 0 ? (arg1 + 8) : (arg1 + 8) + 0)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (arg1 + 20)); + callArgs_1[0] = ((long) (local6 + 20)); + long[] callResult_1 = instance.getMachine().call(157, callArgs_1); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (arg1 + 56)); + callArgs_2[0] = ((long) (local6 + 56)); + long[] callResult_2 = instance.getMachine().call(157, callArgs_2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 92, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 92)); + local7 = (local2 + (local4 * 96)); + local8 = (local6 + 96); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local10 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local10, local9) != 0) { + break label_2; + } + arg1 = 0; + label_7: while (true) { + local4 = (local6 + arg1); + local3 = (local4 + -96); + local2 = (local9 + arg1); + local5 = (local2 + -96); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeI32((int) (local3 + 16) < 0 ? (local3 + 16) : (local3 + 16) + 0, (int) memory.readInt((int) (local5 + 16) < 0 ? (local5 + 16) : (local5 + 16) + 0)); + memory.writeLong((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (long) memory.readLong((int) (local5 + 8) < 0 ? (local5 + 8) : (local5 + 8) + 0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) (local2 + -76)); + callArgs_3[0] = ((long) (local4 + -76)); + long[] callResult_3 = instance.getMachine().call(157, callArgs_3); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (local2 + -40)); + callArgs_4[0] = ((long) (local4 + -40)); + long[] callResult_4 = instance.getMachine().call(157, callArgs_4); + memory.writeI32((int) (local4 + -4) < 0 ? (local4 + -4) : (local4 + -4) + 0, (int) memory.readInt((int) (local2 + -4) < 0 ? (local2 + -4) : (local2 + -4) + 0)); + arg1 = (arg1 + -96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local10, (local9 + arg1)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + local9 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local6 + arg1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, local4) != 0) { + break label_1; + } + label_8: while (true) { + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) (local4 + -40)); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) (local4 + -76)); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + local4 = (local4 + -96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local7); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_9; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local9); + instance.getMachine().call(1777, callArgs_9); + } + return; + } + + public static long[] call_1306(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1306(arg0, arg1, memory, instance); + return null; + } + + public static int func_1307(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + local4 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) arg3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) arg2); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) -1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg0); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 84); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) (local4 + 24)); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) (local4 + 8)); + long[] callResult_1 = instance.getMachine().call(1204, callArgs_1); + arg3 = ((int) callResult_1[0]); + instance.global(0).setValue(((long) (local4 + 112))); + return com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, arg3); + } + + public static long[] call_1307(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1307(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1308(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + long local12 = 0L; + long local13 = 0L; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + local5 = (((int) instance.global(0).getValue()) - 144); + instance.global(0).setValue(((long) local5)); + label_1: { + label_2: { + label_3: { + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local8 = ((local6 - local7) >> 3); + local9 = ((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 4) - memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local9, local8) != 0) { + break label_3; + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local6) != 0) { + break label_4; + } + local10 = 0; + break label_2; + } + local11 = (local5 + 16); + local8 = 0; + local9 = 0; + local10 = 0; + label_5: while (true) { + local12 = memory.readLong((int) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + local8) < 0 ? (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + local8) : (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + local8) + 0); + local13 = memory.readLong((int) (local7 + local8) < 0 ? (local7 + local8) : (local7 + local8) + 0); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 56, (long) local13); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 64, (long) local12); + label_6: { + local14 = (int) local13; + local15 = (int) local12; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local15, local14) != 0) { + break label_6; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 116, (int) 1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local5 + 56)); + callArgs_0[0] = ((long) (local5 + 88)); + instance.getMachine().call(38, callArgs_0); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 88); + local6 = (int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 99); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (local5 + 64)); + callArgs_1[0] = ((long) (local5 + 72)); + instance.getMachine().call(38, callArgs_1); + memory.writeI32((int) local11 < 0 ? local11 : local11 + 0, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 83), 0) != 0 ? memory.readInt((int) local5 < 0 ? local5 : local5 + 72) : (local5 + 72))); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local9); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) 12348); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0) != 0 ? local7 : (local5 + 88))); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local5); + callArgs_2[1] = ((long) 10741); + callArgs_2[0] = ((long) (local5 + 104)); + instance.getMachine().call(39, callArgs_2); + label_7: { + label_8: { + local7 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 8)) != 0) { + break label_8; + } + local16 = memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0); + memory.writeI32((int) ((local5 + 120) + 16) < 0 ? ((local5 + 120) + 16) : ((local5 + 120) + 16) + 0, (int) local16); + local13 = memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + memory.writeLong((int) ((local5 + 120) + 8) < 0 ? ((local5 + 120) + 8) : ((local5 + 120) + 8) + 0, (long) local13); + local12 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0); + local17 = memory.readInt((int) local5 < 0 ? local5 : local5 + 104); + local18 = memory.readInt((int) local5 < 0 ? local5 : local5 + 108); + local6 = (int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 115); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) 1); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 4, (long) local12); + memory.writeLong((int) (local7 + 12) < 0 ? (local7 + 12) : (local7 + 12) + 0, (long) local13); + memory.writeI32((int) (local7 + 20) < 0 ? (local7 + 20) : (local7 + 20) + 0, (int) local16); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 120, (long) local12); + local16 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local6, 0); + local6 = (local16 != 0 ? local18 : (local6 & 255)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 2147483632) != 0) { + break label_1; + } + local18 = (local16 != 0 ? local17 : (local5 + 104)); + label_9: { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 10) != 0) { + break label_10; + } + local16 = (local7 + 24); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 35, (byte) (local6)); + break label_9; + } + local17 = ((local6 | 15) + 1); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local17); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + local16 = ((int) callResult_3[0]); + memory.writeI32((int) (local7 + 32) < 0 ? (local7 + 32) : (local7 + 32) + 0, (int) (local17 | -2147483648)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 24, (int) local16); + memory.writeI32((int) (local7 + 28) < 0 ? (local7 + 28) : (local7 + 28) + 0, (int) local6); + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local6); + callArgs_4[1] = ((long) local18); + callArgs_4[0] = ((long) local16); + long[] callResult_4 = instance.getMachine().call(1891, callArgs_4); + memory.writeByte((int) (((int) callResult_4[0]) + local6) < 0 ? (((int) callResult_4[0]) + local6) : (((int) callResult_4[0]) + local6) + 0, (byte) (0)); + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 4, (int) (local7 + 36)); + break label_7; + } + long[] callArgs_5 = new long[4]; + callArgs_5[3] = ((long) (local5 + 104)); + callArgs_5[2] = ((long) arg0); + callArgs_5[1] = ((long) (local5 + 116)); + callArgs_5[0] = ((long) arg4); + instance.getMachine().call(1309, callArgs_5); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 115), -1) != 0) { + break label_11; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 104)); + instance.getMachine().call(1777, callArgs_6); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 83), -1) != 0) { + break label_12; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 72)); + instance.getMachine().call(1777, callArgs_7); + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 99), -1) != 0) { + break label_13; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 88)); + instance.getMachine().call(1777, callArgs_8); + } + local7 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + local6 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + } + local10 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local10) | com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local15, local14)); + local8 = (local8 + 8); + local9 = (local9 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, ((local6 - local7) >> 3)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break label_2; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 88, (int) 1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 32, (int) local9); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 36, (int) arg3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) local8); + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) (local5 + 32)); + callArgs_9[1] = ((long) 17560); + callArgs_9[0] = ((long) (local5 + 104)); + instance.getMachine().call(39, callArgs_9); + label_14: { + label_15: { + local8 = memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, memory.readInt((int) arg4 < 0 ? arg4 : arg4 + 8)) != 0) { + break label_15; + } + local9 = memory.readInt((int) (arg0 + 16) < 0 ? (arg0 + 16) : (arg0 + 16) + 0); + memory.writeI32((int) ((local5 + 120) + 16) < 0 ? ((local5 + 120) + 16) : ((local5 + 120) + 16) + 0, (int) local9); + local13 = memory.readLong((int) (arg0 + 8) < 0 ? (arg0 + 8) : (arg0 + 8) + 0); + memory.writeLong((int) ((local5 + 120) + 8) < 0 ? ((local5 + 120) + 8) : ((local5 + 120) + 8) + 0, (long) local13); + local12 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 0); + local14 = memory.readInt((int) local5 < 0 ? local5 : local5 + 104); + local10 = memory.readInt((int) local5 < 0 ? local5 : local5 + 108); + local7 = (int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 115); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) 1); + memory.writeLong((int) local8 < 0 ? local8 : local8 + 4, (long) local12); + memory.writeLong((int) (local8 + 12) < 0 ? (local8 + 12) : (local8 + 12) + 0, (long) local13); + memory.writeI32((int) (local8 + 20) < 0 ? (local8 + 20) : (local8 + 20) + 0, (int) local9); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 120, (long) local12); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local7, 0); + local7 = (local9 != 0 ? local10 : (local7 & 255)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local7, 2147483632) != 0) { + break label_1; + } + local10 = (local9 != 0 ? local14 : (local5 + 104)); + label_16: { + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local7, 10) != 0) { + break label_17; + } + local9 = (local8 + 24); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 35, (byte) (local7)); + break label_16; + } + local14 = ((local7 | 15) + 1); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local14); + long[] callResult_10 = instance.getMachine().call(1776, callArgs_10); + local9 = ((int) callResult_10[0]); + memory.writeI32((int) (local8 + 32) < 0 ? (local8 + 32) : (local8 + 32) + 0, (int) (local14 | -2147483648)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 24, (int) local9); + memory.writeI32((int) (local8 + 28) < 0 ? (local8 + 28) : (local8 + 28) + 0, (int) local7); + } + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) local7); + callArgs_11[1] = ((long) local10); + callArgs_11[0] = ((long) local9); + long[] callResult_11 = instance.getMachine().call(1891, callArgs_11); + memory.writeByte((int) (((int) callResult_11[0]) + local7) < 0 ? (((int) callResult_11[0]) + local7) : (((int) callResult_11[0]) + local7) + 0, (byte) (0)); + memory.writeI32((int) arg4 < 0 ? arg4 : arg4 + 4, (int) (local8 + 36)); + break label_14; + } + long[] callArgs_12 = new long[4]; + callArgs_12[3] = ((long) (local5 + 104)); + callArgs_12[2] = ((long) arg0); + callArgs_12[1] = ((long) (local5 + 88)); + callArgs_12[0] = ((long) arg4); + instance.getMachine().call(1309, callArgs_12); + } + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local5 < 0 ? local5 : local5 + 115), -1) != 0) { + break label_18; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) memory.readInt((int) local5 < 0 ? local5 : local5 + 104)); + instance.getMachine().call(1777, callArgs_13); + } + local10 = 1; + } + instance.global(0).setValue(((long) (local5 + 144))); + return local10; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1308(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1308(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1309(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) - local4), 36); + local6 = (local5 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 119304648) != 0) { + break label_4; + } + local7 = 0; + label_5: { + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8) - local4), 36); + local8 = (local4 << 1); + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 59652323) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6) : 119304647); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local4, 119304648) != 0) { + break label_3; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local4 * 36)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local7 = ((int) callResult_0[0]); + } + local6 = (local7 + (local5 * 36)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 4, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (local6 + 12) < 0 ? (local6 + 12) : (local6 + 12) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + memory.writeI32((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0, (int) memory.readInt((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + arg2 = ((int) memory.read((int) arg3 < 0 ? arg3 : arg3 + 11) & 0xFF); + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg2), 0); + arg2 = (arg1 != 0 ? memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4) : arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 2147483632) != 0) { + break label_4; + } + arg1 = (arg1 != 0 ? memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0) : arg3); + local4 = (local4 * 36); + arg3 = (local6 + 24); + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 10) != 0) { + break label_7; + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 35, (byte) (arg2)); + break label_6; + } + local9 = ((arg2 | 15) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1776, callArgs_1); + local8 = ((int) callResult_1[0]); + local5 = (local7 + (local5 * 36)); + memory.writeI32((int) (local5 + 32) < 0 ? (local5 + 32) : (local5 + 32) + 0, (int) (local9 | -2147483648)); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 0, (int) local8); + memory.writeI32((int) (local5 + 28) < 0 ? (local5 + 28) : (local5 + 28) + 0, (int) arg2); + arg3 = local8; + } + local8 = (local7 + local4); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg2); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg3); + long[] callResult_2 = instance.getMachine().call(1891, callArgs_2); + memory.writeByte((int) (((int) callResult_2[0]) + arg2) < 0 ? (((int) callResult_2[0]) + arg2) : (((int) callResult_2[0]) + arg2) + 0, (byte) (0)); + arg1 = (local6 + 36); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, local7) != 0) { + break label_2; + } + label_8: while (true) { + arg3 = (local6 + -36); + arg2 = (local7 + -36); + memory.writeLong((int) arg3 < 0 ? arg3 : arg3 + 0, (long) memory.readLong((int) arg2 < 0 ? arg2 : arg2 + 0)); + memory.writeLong((int) (arg3 + 16) < 0 ? (arg3 + 16) : (arg3 + 16) + 0, (long) memory.readLong((int) (arg2 + 16) < 0 ? (arg2 + 16) : (arg2 + 16) + 0)); + memory.writeLong((int) (arg3 + 8) < 0 ? (arg3 + 8) : (arg3 + 8) + 0, (long) memory.readLong((int) (arg2 + 8) < 0 ? (arg2 + 8) : (arg2 + 8) + 0)); + local6 = (local6 + -12); + local7 = (local7 + -12); + local4 = (local7 + 8); + memory.writeI32((int) (local6 + 8) < 0 ? (local6 + 8) : (local6 + 8) + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) local6 < 0 ? local6 : local6 + 0, (long) memory.readLong((int) local7 < 0 ? local7 : local7 + 0)); + memory.writeLong((int) local7 < 0 ? local7 : local7 + 0, (long) 0L); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + local7 = arg2; + local6 = arg3; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local8); + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) arg3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local7, arg2) != 0) { + break label_1; + } + arg2 = (arg2 + -12); + label_9: while (true) { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (arg2 + 11) < 0 ? (arg2 + 11) : (arg2 + 11) + 0), -1) != 0) { + break label_10; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0)); + instance.getMachine().call(1777, callArgs_3); + } + arg3 = (arg2 + -24); + arg2 = (arg2 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, arg3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break label_1; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local6); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_11; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local7); + instance.getMachine().call(1777, callArgs_6); + } + return; + } + + public static long[] call_1309(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1309(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1310(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + long local8 = 0L; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)) != 0) { + break label_1; + } + local5 = 0; + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_2; + } + label_3: { + label_4: { + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(arg4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, 1) != 0) { + break label_4; + } + local7 = ((arg4 + -1) & arg2); + break label_3; + } + local7 = arg2; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, arg4) != 0) { + break label_3; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg2, arg4); + } + arg3 = memory.readInt((int) (arg3 + (local7 << 2)) < 0 ? (arg3 + (local7 << 2)) : (arg3 + (local7 << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_2; + } + arg3 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_2; + } + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local6, 2) != 0) { + break label_6; + } + local6 = (arg4 + -1); + label_7: while (true) { + label_8: { + label_9: { + arg4 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, arg4) != 0) { + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, (arg4 & local6)) != 0) { + break label_2; + } + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 8)) != 0) { + break label_5; + } + } + arg3 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (arg3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break label_2; + } + } + label_10: while (true) { + label_11: { + label_12: { + local6 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, local6) != 0) { + break label_12; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, arg4) != 0) { + break label_13; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local6, arg4); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local7, local6) != 0) { + break label_2; + } + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg2, memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 8)) != 0) { + break label_5; + } + } + arg3 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 0); + if (arg3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break label_2; + } + } + local5 = arg3; + } + label_14: { + label_15: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local5 + 12)); + callArgs_0[0] = ((long) (arg0 + 288)); + long[] callResult_0 = instance.getMachine().call(120, callArgs_0); + arg3 = ((int) callResult_0[0]); + if (arg3 != 0) { + break label_15; + } + local8 = -21L; + break label_14; + } + local8 = ((((long) memory.readInt((int) (arg3 + 40) < 0 ? (arg3 + 40) : (arg3 + 40) + 0) & 0xFFFFFFFFL) << 32L) | 4294967275L); + } + memory.writeLong((int) arg1 < 0 ? arg1 : arg1 + 0, (long) local8); + } + return; + } + + public static long[] call_1310(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_1310(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static int func_1311(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 47928); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) 0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + return arg0; + } + + public static long[] call_1311(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1311(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1312(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 47928); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) 0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1312(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1312(arg0, memory, instance); + return null; + } + + public static int func_1313(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48148); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 40)); + long[] callResult_0 = instance.getMachine().call(1305, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48220); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_1); + } + return arg0; + } + + public static long[] call_1313(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1313(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1314(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48148); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 40)); + long[] callResult_0 = instance.getMachine().call(1305, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48220); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1314(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1314(arg0, memory, instance); + return null; + } + + public static int func_1315(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48220); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_0); + } + return arg0; + } + + public static long[] call_1315(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1315(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1316(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48220); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1316(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1316(arg0, memory, instance); + return null; + } + + public static void func_1317(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1317(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1317(arg0, memory, instance); + return null; + } + + public static int func_1318(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1318(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1318(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1319(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (arg1 + 12); + arg1 = (arg1 + 48); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1320, callArgs_0); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(1216, callArgs_1); + return ((int) callResult_1[0]); + } + + public static long[] call_1319(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1319(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1320(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + label_1: { + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, memory.readInt((int) (arg2 + 44) < 0 ? (arg2 + 44) : (arg2 + 44) + 0)) != 0) { + break label_1; + } + local5 = 0; + local6 = (arg2 + 68); + local7 = 0; + label_2: while (true) { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + callArgs_0[3] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 64)); + callArgs_0[2] = ((long) local7); + callArgs_0[1] = ((long) (local4 + local5)); + callArgs_0[0] = ((long) local3); + instance.getMachine().call(1310, callArgs_0); + local5 = (local5 + 8); + local7 = (local7 + 1); + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, ((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 44) - local4) >> 3)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + label_3: { + local4 = memory.readInt((int) (arg2 + 52) < 0 ? (arg2 + 52) : (arg2 + 52) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local4, memory.readInt((int) (arg2 + 56) < 0 ? (arg2 + 56) : (arg2 + 56) + 0)) != 0) { + break label_3; + } + local5 = 0; + local6 = (arg2 + 88); + local7 = 0; + label_4: while (true) { + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) memory.readInt((int) local6 < 0 ? local6 : local6 + 0)); + callArgs_1[3] = ((long) memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 84)); + callArgs_1[2] = ((long) local7); + callArgs_1[1] = ((long) (local4 + local5)); + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1310, callArgs_1); + local5 = (local5 + 8); + local7 = (local7 + 1); + local4 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, ((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 56) - local4) >> 3)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg2); + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + long[] callResult_2 = instance.getMachine().call(1214, callArgs_2); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 40), memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 44)) != 0) { + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 56) - memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 52)), 16) != 0) { + break label_5; + } + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg2); + callArgs_3[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + callArgs_3[0] = ((long) arg1); + instance.getMachine().call(1215, callArgs_3); + } + return; + } + + public static long[] call_1320(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1320(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1321(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1321(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1321(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1322(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1322(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1322(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1323(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1323(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1323(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1324(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1324(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1324(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1325(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1325(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1325(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1326(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1326(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1326(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1327(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1327(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1327(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1328(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + long[] callResult_0 = instance.getMachine().call(1214, callArgs_0); + arg1 = (arg1 + 12); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + callArgs_1[0] = ((long) arg1); + instance.getMachine().call(1215, callArgs_1); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(1216, callArgs_2); + return ((int) callResult_2[0]); + } + + public static long[] call_1328(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1328(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1329(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1329(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1329(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1330(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1330(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1330(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1331(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1331(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1331(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1332(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1332(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1332(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1333(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1333(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1333(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1334(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1334(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1334(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1335(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1335(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1335(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1336(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1336(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1336(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1337(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (arg1 + 12); + arg1 = (arg1 + 48); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1320, callArgs_0); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(1216, callArgs_1); + return ((int) callResult_1[0]); + } + + public static long[] call_1337(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1337(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1338(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1338(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1338(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1339(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1339(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1339(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1340(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1340(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1340(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1341(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1341(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1341(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1342(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1342(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1342(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1343(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1343(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1343(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1344(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (arg1 + 12); + arg1 = (arg1 + 48); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1320, callArgs_0); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(1216, callArgs_1); + return ((int) callResult_1[0]); + } + + public static long[] call_1344(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1344(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1345(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1345(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1345(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1346(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1346(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1346(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1347(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1347(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1347(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1348(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1348(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1348(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1349(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1349(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1349(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1350(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1350(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1350(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1351(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1351(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1351(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1352(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1352(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1352(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1353(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1353(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1353(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1354(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1354(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1354(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1355(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1355(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1355(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1356(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1356(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1356(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1357(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1357(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1357(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1358(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1358(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1358(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1359(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1359(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1359(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1360(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1360(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1360(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1361(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1361(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1361(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1362(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1362(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1362(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1363(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1363(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1363(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1364(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1364(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1364(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1365(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1365(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1365(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1366(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (arg1 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + long[] callResult_0 = instance.getMachine().call(1214, callArgs_0); + arg1 = (arg1 + 12); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + callArgs_1[0] = ((long) arg1); + instance.getMachine().call(1215, callArgs_1); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + callArgs_2[2] = ((long) local2); + callArgs_2[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + callArgs_2[0] = ((long) arg1); + long[] callResult_2 = instance.getMachine().call(1216, callArgs_2); + return ((int) callResult_2[0]); + } + + public static long[] call_1366(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1366(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1367(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1367(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1367(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1368(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1368(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1368(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1369(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1369(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1369(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1370(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1370(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1370(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1371(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (arg1 + 12); + arg1 = (arg1 + 52); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1320, callArgs_0); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(1216, callArgs_1); + return ((int) callResult_1[0]); + } + + public static long[] call_1371(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1371(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1372(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1372(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1372(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1373(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1373(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1373(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1374(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1374(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1374(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1375(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1375(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1375(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1376(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1376(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1376(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1377(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1377(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1377(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1378(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1378(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1378(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1379(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1379(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1379(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1380(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1380(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1380(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1381(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1381(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1381(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1382(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1382(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1382(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1383(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1383(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1383(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1384(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1384(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1384(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1385(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1385(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1385(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1386(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1386(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1386(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1387(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1387(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1387(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1388(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1388(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1388(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1389(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1389(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1389(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1390(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1390(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1390(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1391(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 0; + } + + public static long[] call_1391(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1391(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1392(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return arg0; + } + + public static long[] call_1392(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1392(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1393(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48664); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + memory.writeI32((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (int) local1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_0); + } + return arg0; + } + + public static long[] call_1393(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1393(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1394(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48664); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + memory.writeI32((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0, (int) local1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1394(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1394(arg0, memory, instance); + return null; + } + + public static void func_1395(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1395(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1395(arg0, memory, instance); + return null; + } + + public static int func_1396(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48864); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1396(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1396(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1397(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48864); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1397(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1397(arg0, memory, instance); + return null; + } + + public static void func_1398(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1398(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1398(arg0, memory, instance); + return null; + } + + public static int func_1399(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49060); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 72)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 36)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + return arg0; + } + + public static long[] call_1399(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1399(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1400(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49060); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 72)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 36)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1400(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1400(arg0, memory, instance); + return null; + } + + public static int func_1401(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49160); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 72)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 36)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + return arg0; + } + + public static long[] call_1401(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1401(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1402(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49160); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 72)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 36)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1402(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1402(arg0, memory, instance); + return null; + } + + public static void func_1403(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1403(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1403(arg0, memory, instance); + return null; + } + + public static int func_1404(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return arg0; + } + + public static long[] call_1404(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1404(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1405(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1405(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1405(arg0, memory, instance); + return null; + } + + public static void func_1406(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1406(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1406(arg0, memory, instance); + return null; + } + + public static int func_1407(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) local2); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (arg1 + 8)); + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1408, callArgs_0); + local3 = ((int) callResult_0[0]); + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4); + label_1: { + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 1) != 0) { + break label_2; + } + local2 = ((local4 + -1) & local2); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, local4) != 0) { + break label_1; + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local2, local4); + } + label_3: { + label_4: { + label_5: { + if (local3 != 0) { + break label_5; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local2 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local2 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local2 << 2)) + 0, (int) (arg0 + 8)); + local2 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_3; + } + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 1) != 0) { + break label_6; + } + local3 = (local3 & (local4 + -1)); + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0) { + break label_4; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local3, local4); + break label_4; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_3; + } + local3 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 1) != 0) { + break label_8; + } + local3 = (local3 & (local4 + -1)); + break label_7; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, local4) != 0) { + break label_7; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local3, local4); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local3) != 0) { + break label_3; + } + } + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local3 << 2)) + 0, (int) arg1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 1)); + return arg1; + } + + public static long[] call_1407(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1407(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1408(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + float local3 = 0.0f; + float local4 = 0.0f; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local3 = memory.readFloat((int) arg0 < 0 ? arg0 : arg0 + 16); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 1)); + label_1: { + label_2: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(com.dylibso.chicory.runtime.OpcodeImpl.F32_LT((local3 * com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U(local5)), local4)) != 0) { + break label_1; + } + } + local6 = ((local5 << 1) | (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (local5 & (local5 + -1))))); + label_3: { + label_4: { + local3 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CEIL((local4 / local3)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.F32_LT(local3, 4.2949673E9f) & com.dylibso.chicory.runtime.OpcodeImpl.F32_GE(local3, 0.0f))) != 0) { + break label_4; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_TRUNC_F32_U(local3); + break label_3; + } + local7 = 0; + } + local8 = 2; + label_5: { + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local7) != 0 ? local6 : local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local6) != 0) { + break label_5; + } + label_6: { + if ((local6 & (local6 + -1)) != 0) { + break label_6; + } + local8 = local6; + break label_5; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1572, callArgs_0); + local8 = ((int) callResult_0[0]); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local5) != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, local5) != 0) { + break label_7; + } + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 3); + label_9: { + label_10: { + local3 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CEIL((com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)) / memory.readFloat((int) arg0 < 0 ? arg0 : arg0 + 16))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.F32_LT(local3, 4.2949673E9f) & com.dylibso.chicory.runtime.OpcodeImpl.F32_GE(local3, 0.0f))) != 0) { + break label_10; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_TRUNC_F32_U(local3); + break label_9; + } + local6 = 0; + } + label_11: { + label_12: { + if (local7 != 0) { + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local5), 1) != 0) { + break label_12; + } + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 2) != 0 ? local6 : (1 << (32 - com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ((local6 + -1))))); + break label_11; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1572, callArgs_1); + local6 = ((int) callResult_1[0]); + } + local8 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local6) != 0 ? local8 : local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local8, local5) != 0) { + break label_7; + } + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local8); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1409, callArgs_2); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + label_13: { + label_14: { + label_15: { + label_16: { + label_17: { + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 2) != 0) { + break label_17; + } + local6 = arg1; + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, arg1) != 0) { + break label_18; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg1, local5); + } + arg0 = memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) + 0); + if (arg0 != 0) { + break label_16; + } + return 0; + } + local6 = ((local5 + -1) & arg1); + arg0 = memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) + 0); + if (arg0 != 0) { + break label_15; + } + return 0; + } + local9 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, 2) != 0) { + break label_14; + } + local10 = 0; + label_19: while (true) { + local7 = arg0; + arg0 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_13; + } + local8 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + arg2 = local8; + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, local5) != 0) { + break label_20; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local8, local5); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, arg2) != 0) { + break label_13; + } + arg2 = 0; + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local8) != 0) { + break label_21; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + } + local8 = (local10 & (arg2 ^ 1)); + local10 = (local10 | arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, local8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_19; + } + break label_13; + } + } + local9 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + } + local10 = (local5 + -1); + local8 = 0; + label_22: while (true) { + local7 = arg0; + arg0 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_13; + } + arg2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, (arg2 & local10)) != 0) { + break label_13; + } + local5 = 0; + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, arg2) != 0) { + break label_23; + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local9, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8)); + } + arg2 = (local8 & (local5 ^ 1)); + local8 = (local8 | local5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_22; + } + break; + } + } + return local7; + } + + public static long[] call_1408(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1408(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1409(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_4; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg1 << 2)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_6; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + local2 = (arg1 & 3); + local4 = 0; + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 4) != 0) { + break label_7; + } + local5 = (arg1 & -4); + local3 = 8; + local4 = 0; + label_8: while (true) { + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) + 0, (int) 0); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) + 0, (int) 0); + local3 = (local3 + 16); + local4 = (local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_9; + } + local3 = (local4 << 2); + label_10: while (true) { + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 0, (int) 0); + local3 = (local3 + 4); + local2 = (local2 + -1); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + local3 = (arg0 + 8); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 2) != 0) { + break label_3; + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, arg1) != 0) { + break label_11; + } + local6 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local6, arg1); + } + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) + 0, (int) local3); + local2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 2) != 0) { + break label_2; + } + label_12: while (true) { + label_13: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, arg1) != 0) { + break label_13; + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local4, arg1); + } + label_14: { + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + break label_15; + } + local5 = local2; + break label_14; + } + local3 = local2; + label_16: { + local7 = (local4 << 2); + local8 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7); + if (memory.readInt((int) local8 < 0 ? local8 : local8 + 0) != 0) { + break label_16; + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local5); + local5 = local2; + local6 = local4; + break label_14; + } + label_17: { + label_18: while (true) { + local4 = local3; + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local3 < 0 ? local3 : local3 + 8), memory.readInt((int) local2 < 0 ? local2 : local2 + 8)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) + 0) + 0)); + memory.writeI32((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local7) + 0) + 0, (int) local2); + } + local2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break label_1; + } + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 0); + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_19; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) 0); + break label_1; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local6 = (local6 & (arg1 + -1)); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local6 << 2)) + 0, (int) local3); + local2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + } + local7 = (arg1 + -1); + label_20: while (true) { + label_21: { + label_22: { + local4 = (memory.readInt((int) local2 < 0 ? local2 : local2 + 4) & local7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + break label_22; + } + local5 = local2; + break label_21; + } + local3 = local2; + label_23: { + arg1 = (local4 << 2); + local8 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) local8 < 0 ? local8 : local8 + 0)) != 0) { + break label_23; + } + label_24: { + label_25: while (true) { + local4 = local3; + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_24; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local3 < 0 ? local3 : local3 + 8), memory.readInt((int) local2 < 0 ? local2 : local2 + 8)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_25; + } + break; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) + 0)); + memory.writeI32((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) + 0, (int) local2); + break label_21; + } + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local5); + local5 = local2; + local6 = local4; + } + local2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + } + return; + } + + public static long[] call_1409(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1409(arg0, arg1, memory, instance); + return null; + } + + public static int func_1410(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49596); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1410(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1410(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1411(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49596); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1411(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1411(arg0, memory, instance); + return null; + } + + public static int func_1412(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + float local6 = 0.0f; + float local7 = 0.0f; + label_1: { + label_2: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + label_3: { + label_4: { + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 2) != 0) { + break label_4; + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, arg1) != 0) { + break label_5; + } + arg1 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(arg1, local3); + } + local5 = memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (arg1 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (arg1 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (arg1 << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_2; + } + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 2) != 0) { + break label_3; + } + label_6: while (true) { + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_2; + } + label_7: { + local4 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local3) != 0) { + break label_7; + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local4, local3); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local4) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, memory.readInt((int) local5 < 0 ? local5 : local5 + 8)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break label_1; + } + } + arg1 = ((local3 + -1) & arg1); + local5 = memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (arg1 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (arg1 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (arg1 << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_2; + } + arg2 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + } + local4 = (local3 + -1); + label_8: while (true) { + local5 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, (memory.readInt((int) local5 < 0 ? local5 : local5 + 4) & local4)) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, memory.readInt((int) local5 < 0 ? local5 : local5 + 8)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break label_1; + } + } + local6 = memory.readFloat((int) arg0 < 0 ? arg0 : arg0 + 16); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12) + 1)); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_9; + } + local5 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(com.dylibso.chicory.runtime.OpcodeImpl.F32_LT((local6 * com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U(local3)), local7)) != 0) { + break label_1; + } + } + local5 = ((local3 << 1) | (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 3) | com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (local3 & (local3 + -1))))); + label_10: { + label_11: { + local6 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CEIL((local7 / local6)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.F32_LT(local6, 4.2949673E9f) & com.dylibso.chicory.runtime.OpcodeImpl.F32_GE(local6, 0.0f))) != 0) { + break label_11; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_TRUNC_F32_U(local6); + break label_10; + } + arg2 = 0; + } + arg1 = 2; + label_12: { + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, arg2) != 0 ? local5 : arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, local5) != 0) { + break label_12; + } + label_13: { + if ((local5 & (local5 + -1)) != 0) { + break label_13; + } + arg1 = local5; + break label_12; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1572, callArgs_0); + arg1 = ((int) callResult_0[0]); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, local3) != 0) { + break label_14; + } + local5 = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local3) != 0) { + break label_1; + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 3); + label_15: { + label_16: { + local6 = com.dylibso.chicory.runtime.OpcodeImpl.F32_CEIL((com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_U(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)) / memory.readFloat((int) arg0 < 0 ? arg0 : arg0 + 16))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.F32_LT(local6, 4.2949673E9f) & com.dylibso.chicory.runtime.OpcodeImpl.F32_GE(local6, 0.0f))) != 0) { + break label_16; + } + arg2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_TRUNC_F32_U(local6); + break label_15; + } + arg2 = 0; + } + label_17: { + label_18: { + if (local4 != 0) { + break label_18; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(local3), 1) != 0) { + break label_18; + } + arg2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 2) != 0 ? arg2 : (1 << (32 - com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ((arg2 + -1))))); + break label_17; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg2); + long[] callResult_1 = instance.getMachine().call(1572, callArgs_1); + arg2 = ((int) callResult_1[0]); + } + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, arg2) != 0 ? arg1 : arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, local3) != 0) { + break label_1; + } + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1413, callArgs_2); + local5 = 0; + } + return local5; + } + + public static long[] call_1412(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1412(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1413(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 1073741824) != 0) { + break label_4; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg1 << 2)); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local2 = ((int) callResult_0[0]); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local2); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_6; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) arg1); + local2 = (arg1 & 3); + local4 = 0; + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 4) != 0) { + break label_7; + } + local5 = (arg1 & -4); + local3 = 8; + local4 = 0; + label_8: while (true) { + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -8) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + -4) + 0, (int) 0); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 0, (int) 0); + memory.writeI32((int) ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) < 0 ? ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) : ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 4) + 0, (int) 0); + local3 = (local3 + 16); + local4 = (local4 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_9; + } + local3 = (local4 << 2); + label_10: while (true) { + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local3) + 0, (int) 0); + local3 = (local3 + 4); + local2 = (local2 + -1); + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + local3 = (arg0 + 8); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_POPCNT(arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2) != 0) { + break label_3; + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, arg1) != 0) { + break label_11; + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local4, arg1); + } + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local4 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local4 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local4 << 2)) + 0, (int) local3); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 2) != 0) { + break label_2; + } + label_12: while (true) { + label_13: { + local5 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, arg1) != 0) { + break label_13; + } + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local5, arg1); + } + label_14: { + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local5) != 0) { + break label_15; + } + local2 = local3; + break label_14; + } + label_16: { + local6 = (local5 << 2); + local7 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6); + if (memory.readInt((int) local7 < 0 ? local7 : local7 + 0) != 0) { + break label_16; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local2); + local2 = local3; + local4 = local5; + break label_14; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) + 0) + 0)); + memory.writeI32((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + local6) + 0) + 0, (int) local3); + } + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_12; + } + break label_1; + } + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 0); + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local3); + instance.getMachine().call(1777, callArgs_2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) 0); + break label_1; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local4 = (local4 & (arg1 + -1)); + memory.writeI32((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local4 << 2)) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local4 << 2)) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + (local4 << 2)) + 0, (int) local3); + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + } + local6 = (arg1 + -1); + label_18: while (true) { + label_19: { + label_20: { + local5 = (memory.readInt((int) local3 < 0 ? local3 : local3 + 4) & local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local5) != 0) { + break label_20; + } + local2 = local3; + break label_19; + } + label_21: { + arg1 = (local5 << 2); + local7 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) local7 < 0 ? local7 : local7 + 0)) != 0) { + break label_21; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) + 0)); + memory.writeI32((int) memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) < 0 ? memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) : memory.readInt((int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) < 0 ? (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) : (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) + arg1) + 0) + 0, (int) local3); + break label_19; + } + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local2); + local2 = local3; + local4 = local5; + } + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + } + return; + } + + public static long[] call_1413(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1413(arg0, arg1, memory, instance); + return null; + } + + public static int func_1414(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49708); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 8)); + long[] callResult_0 = instance.getMachine().call(32, callArgs_0); + return arg0; + } + + public static long[] call_1414(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1414(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1415(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49708); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 8)); + long[] callResult_0 = instance.getMachine().call(32, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1415(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1415(arg0, memory, instance); + return null; + } + + public static int func_1416(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49816); + label_1: { + local1 = memory.readInt((int) (arg0 + 100) < 0 ? (arg0 + 100) : (arg0 + 100) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) local1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_0); + } + label_2: { + local1 = memory.readInt((int) (arg0 + 88) < 0 ? (arg0 + 88) : (arg0 + 88) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_2; + } + label_3: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local1); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) 0L); + memory.writeI32((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (int) 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 52)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0)); + instance.getMachine().call(1777, callArgs_3); + } + return arg0; + } + + public static long[] call_1416(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1416(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1417(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49816); + label_1: { + local1 = memory.readInt((int) (arg0 + 100) < 0 ? (arg0 + 100) : (arg0 + 100) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) local1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_0); + } + label_2: { + local1 = memory.readInt((int) (arg0 + 88) < 0 ? (arg0 + 88) : (arg0 + 88) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_2; + } + label_3: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local1); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) 0L); + memory.writeI32((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0, (int) 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 52)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0)); + instance.getMachine().call(1777, callArgs_3); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + return; + } + + public static long[] call_1417(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1417(arg0, memory, instance); + return null; + } + + public static int func_1418(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49940); + label_1: { + local1 = memory.readInt((int) (arg0 + 108) < 0 ? (arg0 + 108) : (arg0 + 108) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 112) < 0 ? (arg0 + 112) : (arg0 + 112) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + label_3: while (true) { + label_4: { + local4 = (local3 + -12); + local2 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_4; + } + label_5: while (true) { + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local2); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local2 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + memory.writeLong((int) (local3 + -8) < 0 ? (local3 + -8) : (local3 + -8) + 0, (long) 0L); + local3 = local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 108); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 112, (int) local1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + } + label_6: { + local2 = memory.readInt((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_6; + } + label_7: while (true) { + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + int ciTableIdx_2 = (int) (memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + 4)); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + local2 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 96, (long) 0L); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (arg0 + 52)); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_8; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0)); + instance.getMachine().call(1777, callArgs_4); + } + return arg0; + } + + public static long[] call_1418(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1418(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1419(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 49940); + label_1: { + local1 = memory.readInt((int) (arg0 + 108) < 0 ? (arg0 + 108) : (arg0 + 108) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 112) < 0 ? (arg0 + 112) : (arg0 + 112) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + label_3: while (true) { + label_4: { + local4 = (local3 + -12); + local2 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_4; + } + label_5: while (true) { + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local2); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local2 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) 0); + memory.writeLong((int) (local3 + -8) < 0 ? (local3 + -8) : (local3 + -8) + 0, (long) 0L); + local3 = local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 108); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 112, (int) local1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + } + label_6: { + local2 = memory.readInt((int) (arg0 + 96) < 0 ? (arg0 + 96) : (arg0 + 96) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_6; + } + label_7: while (true) { + local5 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + int ciTableIdx_2 = (int) (memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + 4)); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + local2 = local5; + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 96, (long) 0L); + memory.writeI32((int) (arg0 + 104) < 0 ? (arg0 + 104) : (arg0 + 104) + 0, (int) 0); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (arg0 + 52)); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_8; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0)); + instance.getMachine().call(1777, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + return; + } + + public static long[] call_1419(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1419(arg0, memory, instance); + return null; + } + + public static int func_1420(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50064); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 84)); + long[] callResult_0 = instance.getMachine().call(1305, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 48)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + instance.getMachine().call(1777, callArgs_2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_2; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_3); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_3; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_4); + } + return arg0; + } + + public static long[] call_1420(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1420(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1421(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50064); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 84)); + long[] callResult_0 = instance.getMachine().call(1305, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 48)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + instance.getMachine().call(1777, callArgs_2); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_2; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_3); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_3; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + return; + } + + public static long[] call_1421(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1421(arg0, memory, instance); + return null; + } + + public static void func_1422(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_0); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1422(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1422(arg0, memory, instance); + return null; + } + + public static int func_1423(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50208); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) 0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + return arg0; + } + + public static long[] call_1423(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1423(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1424(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50208); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 36, (int) 0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1424(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1424(arg0, memory, instance); + return null; + } + + public static int func_1425(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50328); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 88)); + long[] callResult_0 = instance.getMachine().call(1305, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 52)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_2); + } + return arg0; + } + + public static long[] call_1425(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1425(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1426(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50328); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 88)); + long[] callResult_0 = instance.getMachine().call(1305, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 52)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_2); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_3); + return; + } + + public static long[] call_1426(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1426(arg0, memory, instance); + return null; + } + + public static int func_1427(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50448); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 52)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_1); + } + return arg0; + } + + public static long[] call_1427(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1427(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1428(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50448); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 52)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1428(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1428(arg0, memory, instance); + return null; + } + + public static int func_1429(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50568); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 32)); + long[] callResult_0 = instance.getMachine().call(1430, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_1); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_2); + } + return arg0; + } + + public static long[] call_1429(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1429(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1430(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 148); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 148, (long) 0L); + memory.writeI32((int) (arg0 + 156) < 0 ? (arg0 + 156) : (arg0 + 156) + 0, (int) 0); + label_3: { + local1 = memory.readInt((int) (arg0 + 136) < 0 ? (arg0 + 136) : (arg0 + 136) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_3; + } + label_4: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) local1 < 0 ? local1 : local1 + 19), -1) != 0) { + break label_5; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 8)); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_2); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 128); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 128, (int) 0); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_6; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_3); + } + label_7: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 116); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_7; + } + memory.writeI32((int) (arg0 + 120) < 0 ? (arg0 + 120) : (arg0 + 120) + 0, (int) local1); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) (arg0 + 52)); + long[] callResult_5 = instance.getMachine().call(1305, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) (arg0 + 16)); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 11), -1) != 0) { + break label_8; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0)); + instance.getMachine().call(1777, callArgs_7); + } + return arg0; + } + + public static long[] call_1430(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1430(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1431(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50568); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 32)); + long[] callResult_0 = instance.getMachine().call(1430, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_1); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_2; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_2); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_3); + return; + } + + public static long[] call_1431(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1431(arg0, memory, instance); + return null; + } + + public static int func_1432(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50672); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(1430, callArgs_0); + return arg0; + } + + public static long[] call_1432(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1432(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1433(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50672); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(1430, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1433(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1433(arg0, memory, instance); + return null; + } + + public static int func_1434(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50792); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + local2 = (local3 + -24); + label_3: while (true) { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + 11) < 0 ? (local2 + 11) : (local2 + 11) + 0), -1) != 0) { + break label_4; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local2); + local2 = (local2 + -24); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 44, (int) local1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48220); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_5; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_2); + } + return arg0; + } + + public static long[] call_1434(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1434(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1435(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50792); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + local2 = (local3 + -24); + label_3: while (true) { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (local2 + 11) < 0 ? (local2 + 11) : (local2 + 11) + 0), -1) != 0) { + break label_4; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) local2 < 0 ? local2 : local2 + 0)); + instance.getMachine().call(1777, callArgs_0); + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local2); + local2 = (local2 + -24); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 44, (int) local1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48220); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_5; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_2); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_3); + return; + } + + public static long[] call_1435(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1435(arg0, memory, instance); + return null; + } + + public static int func_1436(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50840); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48220); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_1); + } + return arg0; + } + + public static long[] call_1436(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1436(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1437(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50840); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 48220); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 35), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24)); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1437(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1437(arg0, memory, instance); + return null; + } + + public static int func_1438(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50888); + label_1: { + local1 = memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 56, (long) 0L); + memory.writeI32((int) (arg0 + 64) < 0 ? (arg0 + 64) : (arg0 + 64) + 0, (int) 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 43), -1) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + instance.getMachine().call(1777, callArgs_1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_4; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_2); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_5; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_3); + } + return arg0; + } + + public static long[] call_1438(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1438(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1439(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50888); + label_1: { + local1 = memory.readInt((int) (arg0 + 56) < 0 ? (arg0 + 56) : (arg0 + 56) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 56, (long) 0L); + memory.writeI32((int) (arg0 + 64) < 0 ? (arg0 + 64) : (arg0 + 64) + 0, (int) 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 43), -1) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + instance.getMachine().call(1777, callArgs_1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_4; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_2); + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_5; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_3); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + return; + } + + public static long[] call_1439(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1439(arg0, memory, instance); + return null; + } + + public static int func_1440(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50996); + label_1: { + local1 = memory.readInt((int) (arg0 + 60) < 0 ? (arg0 + 60) : (arg0 + 60) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 60, (long) 0L); + memory.writeI32((int) (arg0 + 68) < 0 ? (arg0 + 68) : (arg0 + 68) + 0, (int) 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_1); + } + return arg0; + } + + public static long[] call_1440(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1440(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1441(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50996); + label_1: { + local1 = memory.readInt((int) (arg0 + 60) < 0 ? (arg0 + 60) : (arg0 + 60) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 60, (long) 0L); + memory.writeI32((int) (arg0 + 68) < 0 ? (arg0 + 68) : (arg0 + 68) + 0, (int) 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1441(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1441(arg0, memory, instance); + return null; + } + + public static int func_1442(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51116); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_1); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_3; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_2); + } + return arg0; + } + + public static long[] call_1442(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1442(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1443(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51116); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_1); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_3; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_2); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_3); + return; + } + + public static long[] call_1443(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1443(arg0, memory, instance); + return null; + } + + public static int func_1444(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_0); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_1); + } + return arg0; + } + + public static long[] call_1444(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1444(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1445(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51224); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_1); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_3; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_2); + } + return arg0; + } + + public static long[] call_1445(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1445(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1446(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51224); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 43), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + instance.getMachine().call(1777, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 50192); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 27), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16)); + instance.getMachine().call(1777, callArgs_1); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 15), -1) != 0) { + break label_3; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4)); + instance.getMachine().call(1777, callArgs_2); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_3); + return; + } + + public static long[] call_1446(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1446(arg0, memory, instance); + return null; + } + + public static int func_1447(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51332); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40)); + instance.getMachine().call(1777, callArgs_0); + } + return arg0; + } + + public static long[] call_1447(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1447(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1448(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51332); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40)); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1448(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1448(arg0, memory, instance); + return null; + } + + public static int func_1449(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51452); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1449(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1449(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1450(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51452); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1450(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1450(arg0, memory, instance); + return null; + } + + public static int func_1451(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51572); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40)); + instance.getMachine().call(1777, callArgs_0); + } + return arg0; + } + + public static long[] call_1451(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1451(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1452(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51572); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40)); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1452(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1452(arg0, memory, instance); + return null; + } + + public static int func_1453(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51692); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + memory.writeI32((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0, (int) local1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_0); + } + return arg0; + } + + public static long[] call_1453(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1453(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1454(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 51692); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + memory.writeI32((int) (arg0 + 48) < 0 ? (arg0 + 48) : (arg0 + 48) + 0, (int) local1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1454(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1454(arg0, memory, instance); + return null; + } + + public static void func_1455(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1455(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1455(arg0, memory, instance); + return null; + } + + public static void func_1456(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1456(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1456(arg0, memory, instance); + return null; + } + + public static void func_1457(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1457(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1457(arg0, memory, instance); + return null; + } + + public static int func_1458(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52000); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1458(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1458(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1459(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52000); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1459(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1459(arg0, memory, instance); + return null; + } + + public static int func_1460(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52112); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1460(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1460(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1461(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52112); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1461(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1461(arg0, memory, instance); + return null; + } + + public static int func_1462(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52224); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 48)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + local2 = (local3 + -36); + label_3: while (true) { + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + local3 = ((int) callResult_1[0]); + local2 = (local2 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 40, (int) local1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + } + return arg0; + } + + public static long[] call_1462(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1462(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1463(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52224); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 48)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 40) < 0 ? (arg0 + 40) : (arg0 + 40) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + local2 = (local3 + -36); + label_3: while (true) { + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + local3 = ((int) callResult_1[0]); + local2 = (local2 + -36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 40, (int) local1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_3); + return; + } + + public static long[] call_1463(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1463(arg0, memory, instance); + return null; + } + + public static void func_1464(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1464(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1464(arg0, memory, instance); + return null; + } + + public static int func_1465(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52392); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1465(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1465(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1466(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52392); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1466(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1466(arg0, memory, instance); + return null; + } + + public static int func_1467(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52504); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 140)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 76)); + long[] callResult_1 = instance.getMachine().call(1305, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 40)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + return arg0; + } + + public static long[] call_1467(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1467(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1468(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52504); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 140)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 76)); + long[] callResult_1 = instance.getMachine().call(1305, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 40)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_3); + return; + } + + public static long[] call_1468(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1468(arg0, memory, instance); + return null; + } + + public static int func_1469(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52608); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1469(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1469(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1470(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52608); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1470(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1470(arg0, memory, instance); + return null; + } + + public static int func_1471(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52720); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 140)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 76)); + long[] callResult_1 = instance.getMachine().call(1305, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 40)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + return arg0; + } + + public static long[] call_1471(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1471(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1472(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52720); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 140)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 76)); + long[] callResult_1 = instance.getMachine().call(1305, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 40)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_3); + return; + } + + public static long[] call_1472(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1472(arg0, memory, instance); + return null; + } + + public static int func_1473(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52832); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1473(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1473(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1474(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52832); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1474(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1474(arg0, memory, instance); + return null; + } + + public static int func_1475(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52944); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1475(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1475(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1476(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 52944); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1476(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1476(arg0, memory, instance); + return null; + } + + public static int func_1477(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53056); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1477(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1477(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1478(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53056); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1478(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1478(arg0, memory, instance); + return null; + } + + public static int func_1479(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53168); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1479(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1479(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1480(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53168); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1480(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1480(arg0, memory, instance); + return null; + } + + public static int func_1481(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53280); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1481(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1481(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1482(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53280); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1482(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1482(arg0, memory, instance); + return null; + } + + public static void func_1483(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53564); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1483(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1483(arg0, memory, instance); + return null; + } + + public static int func_1484(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53564); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1484(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1484(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1485(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53564); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1485(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1485(arg0, memory, instance); + return null; + } + + public static void func_1486(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53752); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1486(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1486(arg0, memory, instance); + return null; + } + + public static int func_1487(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53752); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1487(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1487(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1488(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 53752); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1488(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1488(arg0, memory, instance); + return null; + } + + public static void func_1489(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1489(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1489(arg0, memory, instance); + return null; + } + + public static void func_1490(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1490(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1490(arg0, memory, instance); + return null; + } + + public static void func_1491(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1491(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1491(arg0, memory, instance); + return null; + } + + public static void func_1492(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1492(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1492(arg0, memory, instance); + return null; + } + + public static int func_1493(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54232); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 72)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 36)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + return arg0; + } + + public static long[] call_1493(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1493(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1494(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54232); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 72)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 36)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1494(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1494(arg0, memory, instance); + return null; + } + + public static int func_1495(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54356); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1495(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1495(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1496(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54356); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1496(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1496(arg0, memory, instance); + return null; + } + + public static int func_1497(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54472); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1497(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1497(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1498(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54472); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1498(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1498(arg0, memory, instance); + return null; + } + + public static int func_1499(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54584); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 72)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54756); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 36)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + return arg0; + } + + public static long[] call_1499(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1499(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1500(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54584); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 72)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54756); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 36)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1500(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1500(arg0, memory, instance); + return null; + } + + public static int func_1501(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54756); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1501(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1501(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1502(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54756); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1502(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1502(arg0, memory, instance); + return null; + } + + public static int func_1503(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54772); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1503(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1503(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1504(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54772); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1504(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1504(arg0, memory, instance); + return null; + } + + public static int func_1505(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54888); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1505(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1505(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1506(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 54888); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1506(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1506(arg0, memory, instance); + return null; + } + + public static int func_1507(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55004); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1507(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1507(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1508(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55004); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1508(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1508(arg0, memory, instance); + return null; + } + + public static int func_1509(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55116); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1509(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1509(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1510(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55116); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1510(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1510(arg0, memory, instance); + return null; + } + + public static int func_1511(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55228); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1511(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1511(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1512(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55228); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1512(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1512(arg0, memory, instance); + return null; + } + + public static int func_1513(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55340); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1513(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1513(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1514(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55340); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1514(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1514(arg0, memory, instance); + return null; + } + + public static int func_1515(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55452); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1515(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1515(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1516(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55452); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1516(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1516(arg0, memory, instance); + return null; + } + + public static int func_1517(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55564); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1517(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1517(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1518(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55564); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1518(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1518(arg0, memory, instance); + return null; + } + + public static void func_1519(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1519(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1519(arg0, memory, instance); + return null; + } + + public static void func_1520(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1520(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1520(arg0, memory, instance); + return null; + } + + public static int func_1521(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55864); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1521(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1521(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1522(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 55864); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1522(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1522(arg0, memory, instance); + return null; + } + + public static void func_1523(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1523(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1523(arg0, memory, instance); + return null; + } + + public static int func_1524(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56044); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1524(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1524(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1525(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56044); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1525(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1525(arg0, memory, instance); + return null; + } + + public static int func_1526(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56324); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1526(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1526(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1527(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56324); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1527(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1527(arg0, memory, instance); + return null; + } + + public static void func_1528(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56324); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1528(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1528(arg0, memory, instance); + return null; + } + + public static int func_1529(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56508); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1529(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1529(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1530(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56508); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1530(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1530(arg0, memory, instance); + return null; + } + + public static void func_1531(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56508); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1531(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1531(arg0, memory, instance); + return null; + } + + public static int func_1532(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56692); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1532(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1532(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1533(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56692); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1533(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1533(arg0, memory, instance); + return null; + } + + public static void func_1534(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56692); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1534(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1534(arg0, memory, instance); + return null; + } + + public static int func_1535(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56876); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1535(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1535(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1536(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56876); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1536(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1536(arg0, memory, instance); + return null; + } + + public static void func_1537(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 56876); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1537(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1537(arg0, memory, instance); + return null; + } + + public static int func_1538(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57060); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1538(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1538(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1539(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57060); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1539(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1539(arg0, memory, instance); + return null; + } + + public static void func_1540(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57060); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1540(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1540(arg0, memory, instance); + return null; + } + + public static int func_1541(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57244); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1541(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1541(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1542(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57244); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1542(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1542(arg0, memory, instance); + return null; + } + + public static void func_1543(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57244); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1543(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1543(arg0, memory, instance); + return null; + } + + public static void func_1544(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_0); + return; + } + + public static long[] call_1544(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1544(arg0, memory, instance); + return null; + } + + public static int func_1545(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57532); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1545(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1545(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1546(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57532); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1546(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1546(arg0, memory, instance); + return null; + } + + public static void func_1547(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57532); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1547(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1547(arg0, memory, instance); + return null; + } + + public static int func_1548(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57704); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + return arg0; + } + + public static long[] call_1548(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1548(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1549(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57704); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1549(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1549(arg0, memory, instance); + return null; + } + + public static void func_1550(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57704); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 36)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1550(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1550(arg0, memory, instance); + return null; + } + + public static int func_1551(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57720); + label_1: { + local1 = memory.readInt((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 152, (long) 0L); + memory.writeI32((int) (arg0 + 160) < 0 ? (arg0 + 160) : (arg0 + 160) + 0, (int) 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 88)); + long[] callResult_1 = instance.getMachine().call(1305, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 52)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_3); + } + return arg0; + } + + public static long[] call_1551(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1551(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1552(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57720); + label_1: { + local1 = memory.readInt((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 152, (long) 0L); + memory.writeI32((int) (arg0 + 160) < 0 ? (arg0 + 160) : (arg0 + 160) + 0, (int) 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 88)); + long[] callResult_1 = instance.getMachine().call(1305, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 52)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_3); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + return; + } + + public static long[] call_1552(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1552(arg0, memory, instance); + return null; + } + + public static int func_1553(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57840); + label_1: { + local1 = memory.readInt((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 152, (long) 0L); + memory.writeI32((int) (arg0 + 160) < 0 ? (arg0 + 160) : (arg0 + 160) + 0, (int) 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 88)); + long[] callResult_1 = instance.getMachine().call(1305, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 52)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_3); + } + return arg0; + } + + public static long[] call_1553(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1553(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1554(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57840); + label_1: { + local1 = memory.readInt((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 152, (long) 0L); + memory.writeI32((int) (arg0 + 160) < 0 ? (arg0 + 160) : (arg0 + 160) + 0, (int) 0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 88)); + long[] callResult_1 = instance.getMachine().call(1305, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 52)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_3; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_3); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_4); + return; + } + + public static long[] call_1554(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1554(arg0, memory, instance); + return null; + } + + public static int func_1555(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57960); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 184); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 184, (long) 0L); + memory.writeI32((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0, (int) 0); + label_3: { + local1 = memory.readInt((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_3; + } + label_4: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local1); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 152, (long) 0L); + memory.writeI32((int) (arg0 + 160) < 0 ? (arg0 + 160) : (arg0 + 160) + 0, (int) 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 88)); + long[] callResult_2 = instance.getMachine().call(1305, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (arg0 + 52)); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_5; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_4); + } + return arg0; + } + + public static long[] call_1555(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1555(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1556(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 57960); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 184); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + label_2: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 184, (long) 0L); + memory.writeI32((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0, (int) 0); + label_3: { + local1 = memory.readInt((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_3; + } + label_4: while (true) { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 4); + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local1); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local1 = local2; + if (local2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 152, (long) 0L); + memory.writeI32((int) (arg0 + 160) < 0 ? (arg0 + 160) : (arg0 + 160) + 0, (int) 0); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (arg0 + 88)); + long[] callResult_2 = instance.getMachine().call(1305, callArgs_2); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (arg0 + 52)); + long[] callResult_3 = instance.getMachine().call(162, callArgs_3); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_5; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_5); + return; + } + + public static long[] call_1556(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1556(arg0, memory, instance); + return null; + } + + public static int func_1557(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58052); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 200)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 188); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 192) < 0 ? (arg0 + 192) : (arg0 + 192) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + label_3: while (true) { + label_4: { + local4 = (local3 + -68); + local5 = (local4 + 56); + local2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_4; + } + label_5: while (true) { + local6 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + 4)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local2); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local2 = local6; + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + memory.writeLong((int) (local3 + -8) < 0 ? (local3 + -8) : (local3 + -8) + 0, (long) 0L); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (local3 + -48)); + long[] callResult_2 = instance.getMachine().call(162, callArgs_2); + local3 = local4; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 188); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 192, (int) local1); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_3); + } + label_6: { + local2 = memory.readInt((int) (arg0 + 156) < 0 ? (arg0 + 156) : (arg0 + 156) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_6; + } + label_7: while (true) { + local6 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) local2 < 0 ? local2 : local2 + 0) < 0 ? memory.readInt((int) local2 < 0 ? local2 : local2 + 0) : memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + 4)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local2); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + local2 = local6; + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 156, (long) 0L); + memory.writeI32((int) (arg0 + 164) < 0 ? (arg0 + 164) : (arg0 + 164) + 0, (int) 0); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) (arg0 + 92)); + long[] callResult_5 = instance.getMachine().call(1305, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) (arg0 + 56)); + long[] callResult_6 = instance.getMachine().call(162, callArgs_6); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 51), -1) != 0) { + break label_8; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40)); + instance.getMachine().call(1777, callArgs_7); + } + return arg0; + } + + public static long[] call_1557(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1557(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1558(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1557, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) ((int) callResult_0[0])); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1558(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1558(arg0, memory, instance); + return null; + } + + public static int func_1559(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58148); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 184); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 188) < 0 ? (arg0 + 188) : (arg0 + 188) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + label_3: while (true) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + -40)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + -76)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + local3 = (local3 + -96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 184); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 188, (int) local1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + } + label_4: { + local3 = memory.readInt((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_4; + } + label_5: while (true) { + local1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = local1; + if (local1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 152, (long) 0L); + memory.writeI32((int) (arg0 + 160) < 0 ? (arg0 + 160) : (arg0 + 160) + 0, (int) 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) (arg0 + 88)); + long[] callResult_4 = instance.getMachine().call(1305, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) (arg0 + 52)); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_6; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_6); + } + return arg0; + } + + public static long[] call_1559(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1559(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1560(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58148); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 184); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + local2 = local1; + label_2: { + local3 = memory.readInt((int) (arg0 + 188) < 0 ? (arg0 + 188) : (arg0 + 188) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local3) != 0) { + break label_2; + } + label_3: while (true) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (local3 + -40)); + long[] callResult_0 = instance.getMachine().call(162, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + -76)); + long[] callResult_1 = instance.getMachine().call(162, callArgs_1); + local3 = (local3 + -96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local1, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 184); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 188, (int) local1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local2); + instance.getMachine().call(1777, callArgs_2); + } + label_4: { + local3 = memory.readInt((int) (arg0 + 152) < 0 ? (arg0 + 152) : (arg0 + 152) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_4; + } + label_5: while (true) { + local1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) local3 < 0 ? local3 : local3 + 0) < 0 ? memory.readInt((int) local3 < 0 ? local3 : local3 + 0) : memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + 4)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local3 = local1; + if (local1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 152, (long) 0L); + memory.writeI32((int) (arg0 + 160) < 0 ? (arg0 + 160) : (arg0 + 160) + 0, (int) 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) (arg0 + 88)); + long[] callResult_4 = instance.getMachine().call(1305, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) (arg0 + 52)); + long[] callResult_5 = instance.getMachine().call(162, callArgs_5); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 47), -1) != 0) { + break label_6; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + instance.getMachine().call(1777, callArgs_6); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_7); + return; + } + + public static long[] call_1560(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1560(arg0, memory, instance); + return null; + } + + public static int func_1561(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58248); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 412); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 412, (int) 0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 8)); + long[] callResult_1 = instance.getMachine().call(32, callArgs_1); + return arg0; + } + + public static long[] call_1561(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1561(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1562(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58248); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 412); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 412, (int) 0); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0) < 0 ? memory.readInt((int) local1 < 0 ? local1 : local1 + 0) : memory.readInt((int) local1 < 0 ? local1 : local1 + 0) + 4)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (arg0 + 8)); + long[] callResult_1 = instance.getMachine().call(32, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1562(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1562(arg0, memory, instance); + return null; + } + + public static int func_1563(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58364); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + memory.writeI32((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0, (int) local1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_0); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 39), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28)); + instance.getMachine().call(1777, callArgs_1); + } + return arg0; + } + + public static long[] call_1563(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1563(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1564(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58364); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + memory.writeI32((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0, (int) local1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_0); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 39), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28)); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1564(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1564(arg0, memory, instance); + return null; + } + + public static int func_1565(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return (arg0 + 8); + } + + public static long[] call_1565(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1565(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1566(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58548); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + memory.writeI32((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0, (int) local1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_0); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 39), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28)); + instance.getMachine().call(1777, callArgs_1); + } + return arg0; + } + + public static long[] call_1566(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1566(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1567(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58548); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_1; + } + memory.writeI32((int) (arg0 + 44) < 0 ? (arg0 + 44) : (arg0 + 44) + 0, (int) local1); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local1); + instance.getMachine().call(1777, callArgs_0); + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 39), -1) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28)); + instance.getMachine().call(1777, callArgs_1); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_2); + return; + } + + public static long[] call_1567(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1567(arg0, memory, instance); + return null; + } + + public static int func_1568(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return (arg0 + 8); + } + + public static long[] call_1568(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1568(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1569(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58700); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 8)); + long[] callResult_0 = instance.getMachine().call(32, callArgs_0); + return arg0; + } + + public static long[] call_1569(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1569(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1570(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) 58700); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) (arg0 + 8)); + long[] callResult_0 = instance.getMachine().call(32, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1777, callArgs_1); + return; + } + + public static long[] call_1570(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1570(arg0, memory, instance); + return null; + } + + public static int func_1571(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return (arg0 + 8); + } + + public static long[] call_1571(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1571(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1572(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[1221]; + iL[0] = arg0; + iL[1] = ((int) instance.global(0).getValue()); + iL[2] = 64; + iL[3] = (iL[1] - iL[2]); + instance.global(0).setValue(((long) iL[3])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 56, (int) iL[0]); + iL[4] = 210; + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 52, (int) iL[4]); + iL[5] = 48; + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 48, (int) iL[5]); + iL[6] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[7] = 0; + iL[8] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 59004); + iL[9] = iL[6]; + iL[10] = iL[8]; + iL[11] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[9], iL[10]); + iL[12] = 1; + iL[13] = (iL[11] & iL[12]); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_2; + } + iL[14] = 58816; + iL[15] = 192; + iL[16] = (iL[14] + iL[15]); + iL[17] = 56; + iL[18] = (iL[3] + iL[17]); + iL[19] = iL[18]; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) iL[19]); + callArgs_0[1] = ((long) iL[16]); + callArgs_0[0] = ((long) iL[14]); + long[] callResult_0 = instance.getMachine().call(1573, callArgs_0); + iL[20] = ((int) callResult_0[0]); + iL[21] = memory.readInt((int) iL[20] < 0 ? iL[20] : iL[20] + 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[21]); + break label_1; + } + iL[22] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) iL[22]); + instance.getMachine().call(1574, callArgs_1); + iL[23] = 48; + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 44, (int) iL[23]); + iL[24] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[25] = 210; + iL[26] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[24], iL[25]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 40, (int) iL[26]); + iL[27] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[28] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 40); + iL[29] = 210; + iL[30] = (iL[28] * iL[29]); + iL[31] = (iL[27] - iL[30]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 32, (int) iL[31]); + iL[32] = 59008; + iL[33] = 192; + iL[34] = (iL[32] + iL[33]); + iL[35] = 32; + iL[36] = (iL[3] + iL[35]); + iL[37] = iL[36]; + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) iL[37]); + callArgs_2[1] = ((long) iL[34]); + callArgs_2[0] = ((long) iL[32]); + long[] callResult_2 = instance.getMachine().call(1573, callArgs_2); + iL[38] = ((int) callResult_2[0]); + iL[39] = 59008; + iL[40] = (iL[38] - iL[39]); + iL[41] = 2; + iL[42] = (iL[40] >> iL[41]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (int) iL[42]); + iL[43] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 40); + iL[44] = 210; + iL[45] = (iL[43] * iL[44]); + iL[46] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 36); + iL[47] = 59008; + iL[48] = 2; + iL[49] = (iL[46] << iL[48]); + iL[50] = (iL[47] + iL[49]); + iL[51] = memory.readInt((int) iL[50] < 0 ? iL[50] : iL[50] + 0); + iL[52] = (iL[45] + iL[51]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 56, (int) iL[52]); + label_3: while (true) { + iL[53] = 5; + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 28, (int) iL[53]); + label_4: { + label_5: { + label_6: while (true) { + iL[54] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 28); + iL[55] = 47; + iL[56] = iL[54]; + iL[57] = iL[55]; + iL[58] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[56], iL[57]); + iL[59] = 1; + iL[60] = (iL[58] & iL[59]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[60]) != 0) { + break label_5; + } + iL[61] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 28); + iL[62] = 58816; + iL[63] = 2; + iL[64] = (iL[61] << iL[63]); + iL[65] = (iL[62] + iL[64]); + iL[66] = memory.readInt((int) iL[65] < 0 ? iL[65] : iL[65] + 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 24, (int) iL[66]); + iL[67] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[68] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 24); + iL[69] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[67], iL[68]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 20, (int) iL[69]); + iL[70] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 20); + iL[71] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 24); + iL[72] = iL[70]; + iL[73] = iL[71]; + iL[74] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[72], iL[73]); + iL[75] = 1; + iL[76] = (iL[74] & iL[75]); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[76]) != 0) { + break label_7; + } + iL[77] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[77]); + break label_1; + } + iL[78] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[79] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 20); + iL[80] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 24); + iL[81] = (iL[79] * iL[80]); + iL[82] = iL[78]; + iL[83] = iL[81]; + iL[84] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[83], iL[82]); + iL[85] = 1; + iL[86] = (iL[84] & iL[85]); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[86]) != 0) { + break label_8; + } + break label_4; + } + iL[87] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 28); + iL[88] = 1; + iL[89] = (iL[87] + iL[88]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 28, (int) iL[89]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + } + iL[90] = 211; + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[90]); + label_9: while (true) { + iL[91] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[92] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[93] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[91], iL[92]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[93]); + iL[94] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[95] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[96] = iL[94]; + iL[97] = iL[95]; + iL[98] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[96], iL[97]); + iL[99] = 1; + iL[100] = (iL[98] & iL[99]); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[100]) != 0) { + break label_10; + } + iL[101] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[101]); + break label_1; + } + iL[102] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[103] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[104] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[105] = (iL[103] * iL[104]); + iL[106] = iL[102]; + iL[107] = iL[105]; + iL[108] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[107], iL[106]); + iL[109] = 1; + iL[110] = (iL[108] & iL[109]); + label_11: { + int _d0 = func_1572__h0(iL, memory, instance); + if (_d0 == 1) + break label_1; + if (_d0 == 2) + continue label_9; + } + break; + } + } + iL[1195] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 36); + iL[1196] = 1; + iL[1197] = (iL[1195] + iL[1196]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (int) iL[1197]); + iL[1198] = 48; + iL[1199] = iL[1197]; + iL[1200] = iL[1198]; + iL[1201] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1200], iL[1199]); + iL[1202] = 1; + iL[1203] = (iL[1201] & iL[1202]); + label_107: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1203]) != 0) { + break label_107; + } + iL[1204] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 40); + iL[1205] = 1; + iL[1206] = (iL[1204] + iL[1205]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 40, (int) iL[1206]); + iL[1207] = 0; + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (int) iL[1207]); + } + iL[1208] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 40); + iL[1209] = 210; + iL[1210] = (iL[1208] * iL[1209]); + iL[1211] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 36); + iL[1212] = 59008; + iL[1213] = 2; + iL[1214] = (iL[1211] << iL[1213]); + iL[1215] = (iL[1212] + iL[1214]); + iL[1216] = memory.readInt((int) iL[1215] < 0 ? iL[1215] : iL[1215] + 0); + iL[1217] = (iL[1210] + iL[1216]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 56, (int) iL[1217]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + } + iL[1218] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 60); + iL[1219] = 64; + iL[1220] = (iL[3] + iL[1219]); + instance.global(0).setValue(((long) iL[1220])); + return iL[1218]; + } + + public static long[] call_1572(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1572(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1573(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local8); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1575, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = 16; + local11 = (local5 + local10); + instance.global(0).setValue(((long) local11)); + return local9; + } + + public static long[] call_1573(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1573(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1574(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = -5; + local6 = local4; + local7 = local5; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local7); + local9 = 1; + local10 = (local8 & local9); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_1; + } + local11 = 2780; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local11); + instance.getMachine().call(1576, callArgs_0); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local12 = 16; + local13 = (local3 + local12); + instance.global(0).setValue(((long) local13)); + return; + } + + public static long[] call_1574(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1574(arg0, memory, instance); + return null; + } + + public static int func_1575(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg2); + local6 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 8, (byte) (local6)); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local10 = 24; + local11 = (local5 + local10); + local12 = local11; + local13 = 8; + local14 = (local5 + local13); + local15 = local14; + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) local15); + callArgs_0[3] = ((long) local12); + callArgs_0[2] = ((long) local9); + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1577, callArgs_0); + local16 = ((int) callResult_0[0]); + local17 = 32; + local18 = (local5 + local17); + instance.global(0).setValue(((long) local18)); + return local16; + } + + public static long[] call_1575(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1575(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1576(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1576(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1576(arg0, memory, instance); + return null; + } + + public static int func_1577(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + local5 = ((int) instance.global(0).getValue()); + local6 = 32; + local7 = (local5 - local6); + instance.global(0).setValue(((long) local7)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) arg0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 24, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 20, (int) arg2); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 16, (int) arg3); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) arg4); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 28); + local9 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local9); + callArgs_0[0] = ((long) local8); + long[] callResult_0 = instance.getMachine().call(1578, callArgs_0); + local10 = ((int) callResult_0[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 8, (int) local10); + label_1: { + label_2: while (true) { + local11 = memory.readInt((int) local7 < 0 ? local7 : local7 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_1; + } + local12 = memory.readInt((int) local7 < 0 ? local7 : local7 + 8); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local12); + long[] callResult_1 = instance.getMachine().call(1579, callArgs_1); + local13 = ((int) callResult_1[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 4, (int) local13); + local14 = memory.readInt((int) local7 < 0 ? local7 : local7 + 28); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local14); + local15 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + local16 = local7; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local15); + callArgs_2[0] = ((long) local16); + instance.getMachine().call(1580, callArgs_2); + local17 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local18 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local19 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local19); + callArgs_3[0] = ((long) local18); + long[] callResult_3 = instance.getMachine().call(1581, callArgs_3); + local20 = ((int) callResult_3[0]); + local21 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local21); + callArgs_4[1] = ((long) local20); + callArgs_4[0] = ((long) local17); + long[] callResult_4 = instance.getMachine().call(1582, callArgs_4); + local22 = ((int) callResult_4[0]); + local23 = 1; + local24 = (local22 & local23); + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local24) != 0) { + break label_4; + } + local25 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + local26 = 4; + local27 = (local25 + local26); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local27); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) local27); + local28 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + local29 = 1; + local30 = (local28 + local29); + local31 = memory.readInt((int) local7 < 0 ? local7 : local7 + 8); + local32 = (local31 - local30); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 8, (int) local32); + break label_3; + } + local33 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 8, (int) local33); + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + } + local34 = memory.readInt((int) local7 < 0 ? local7 : local7 + 28); + local35 = 32; + local36 = (local7 + local35); + instance.global(0).setValue(((long) local36)); + return local34; + } + + public static long[] call_1577(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1577(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1578(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1583, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1578(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1578(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1579(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = 1; + local6 = (local4 >>> local5); + return local6; + } + + public static long[] call_1579(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1579(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1580(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + instance.getMachine().call(1584, callArgs_0); + local7 = 16; + local8 = (local4 + local7); + instance.global(0).setValue(((long) local8)); + return; + } + + public static long[] call_1580(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1580(arg0, arg1, memory, instance); + return null; + } + + public static int func_1581(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1586, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1581(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1581(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1582(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local8); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1585, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = 1; + local11 = (local9 & local10); + local12 = 16; + local13 = (local5 + local12); + instance.global(0).setValue(((long) local13)); + return local11; + } + + public static long[] call_1582(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1582(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1583(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1587, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1583(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1583(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1584(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1588, callArgs_0); + local6 = ((int) callResult_0[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local6); + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local8 = 0; + local9 = local7; + local10 = local8; + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(local9, local10); + local12 = 1; + local13 = 1; + local14 = (local11 & local13); + local15 = local12; + label_1: { + if (local14 != 0) { + break label_1; + } + local16 = 1; + local15 = local16; + } + local17 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local18 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local18); + callArgs_1[0] = ((long) local17); + instance.getMachine().call(1589, callArgs_1); + local19 = 16; + local20 = (local4 + local19); + instance.global(0).setValue(((long) local20)); + return; + } + + public static long[] call_1584(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1584(arg0, arg1, memory, instance); + return null; + } + + public static int func_1585(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local10 = local7; + local11 = local9; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, local11); + local13 = 1; + local14 = (local12 & local13); + return local14; + } + + public static long[] call_1585(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1585(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1586(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + return local5; + } + + public static long[] call_1586(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1586(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1587(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local7 = (local5 - local6); + local8 = 2; + local9 = (local7 >> local8); + return local9; + } + + public static long[] call_1587(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1587(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1588(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1588(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1588(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1589(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local8 = 2; + local9 = (local5 << local8); + local10 = (local7 + local9); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local10); + return; + } + + public static long[] call_1589(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1589(arg0, arg1, memory, instance); + return null; + } + + public static int func_1590(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1599, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 1; + local7 = (local5 & local6); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1600, callArgs_1); + local8 = ((int) callResult_1[0]); + local9 = local8; + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(1601, callArgs_2); + local10 = ((int) callResult_2[0]); + local9 = local10; + } + local11 = local9; + local12 = 16; + local13 = (local3 + local12); + instance.global(0).setValue(((long) local13)); + return local11; + } + + public static long[] call_1590(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1590(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1591(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = 14330; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1602, callArgs_0); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1591(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1591(arg0, memory, instance); + return null; + } + + public static int func_1592(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1603, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1592(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1592(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1593(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1599, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 1; + local7 = (local5 & local6); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1604, callArgs_1); + local8 = ((int) callResult_1[0]); + local9 = local8; + break label_1; + } + local10 = 11; + local9 = local10; + } + local11 = local9; + local12 = 1; + local13 = (local11 - local12); + local14 = 16; + local15 = (local3 + local14); + instance.global(0).setValue(((long) local15)); + return local13; + } + + public static long[] call_1593(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1593(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1594(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1599, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 1; + local7 = (local5 & local6); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1605, callArgs_1); + local8 = ((int) callResult_1[0]); + local9 = local8; + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(1606, callArgs_2); + local10 = ((int) callResult_2[0]); + local9 = local10; + } + local11 = local9; + local12 = 16; + local13 = (local3 + local12); + instance.global(0).setValue(((long) local13)); + return local11; + } + + public static long[] call_1594(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1594(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1595(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1595(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1595(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1596(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local8); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1607, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = 16; + local11 = (local5 + local10); + instance.global(0).setValue(((long) local11)); + return local9; + } + + public static long[] call_1596(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1596(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1597(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + instance.getMachine().call(1608, callArgs_0); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local8); + callArgs_1[0] = ((long) local6); + instance.getMachine().call(1609, callArgs_1); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local10 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local11 = (local9 + local10); + local12 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 3, (byte) (local12)); + local13 = 3; + local14 = (local5 + local13); + local15 = local14; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local15); + callArgs_2[0] = ((long) local11); + instance.getMachine().call(1610, callArgs_2); + local16 = 16; + local17 = (local5 + local16); + instance.global(0).setValue(((long) local17)); + return local6; + } + + public static long[] call_1597(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1597(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1598(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + int local84 = 0; + int local85 = 0; + int local86 = 0; + int local87 = 0; + int local88 = 0; + int local89 = 0; + int local90 = 0; + int local91 = 0; + int local92 = 0; + int local93 = 0; + int local94 = 0; + int local95 = 0; + int local96 = 0; + int local97 = 0; + int local98 = 0; + int local99 = 0; + int local100 = 0; + int local101 = 0; + int local102 = 0; + int local103 = 0; + int local104 = 0; + int local105 = 0; + int local106 = 0; + int local107 = 0; + int local108 = 0; + int local109 = 0; + int local110 = 0; + int local111 = 0; + int local112 = 0; + int local113 = 0; + int local114 = 0; + int local115 = 0; + int local116 = 0; + int local117 = 0; + int local118 = 0; + int local119 = 0; + int local120 = 0; + int local121 = 0; + int local122 = 0; + int local123 = 0; + int local124 = 0; + int local125 = 0; + int local126 = 0; + int local127 = 0; + int local128 = 0; + local8 = ((int) instance.global(0).getValue()); + local9 = 80; + local10 = (local8 - local9); + instance.global(0).setValue(((long) local10)); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 76, (int) arg0); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 72, (int) arg1); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 68, (int) arg2); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 64, (int) arg3); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 60, (int) arg4); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 56, (int) arg5); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 52, (int) arg6); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 48, (int) arg7); + local11 = memory.readInt((int) local10 < 0 ? local10 : local10 + 76); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local11); + long[] callResult_0 = instance.getMachine().call(1611, callArgs_0); + local12 = ((int) callResult_0[0]); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 44, (int) local12); + local13 = memory.readInt((int) local10 < 0 ? local10 : local10 + 68); + local14 = memory.readInt((int) local10 < 0 ? local10 : local10 + 44); + local15 = memory.readInt((int) local10 < 0 ? local10 : local10 + 72); + local16 = (local14 - local15); + local17 = 1; + local18 = (local16 - local17); + local19 = local13; + local20 = local18; + local21 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local19, local20); + local22 = 1; + local23 = (local21 & local22); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local23) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local11); + instance.getMachine().call(1612, callArgs_1); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local11); + long[] callResult_2 = instance.getMachine().call(1594, callArgs_2); + local24 = ((int) callResult_2[0]); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 40, (int) local24); + local25 = memory.readInt((int) local10 < 0 ? local10 : local10 + 72); + local26 = memory.readInt((int) local10 < 0 ? local10 : local10 + 44); + local27 = 1; + local28 = (local26 >>> local27); + local29 = 16; + local30 = (local28 - local29); + local31 = local25; + local32 = local30; + local33 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local31, local32); + local34 = 1; + local35 = (local33 & local34); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local35) != 0) { + break label_3; + } + local36 = memory.readInt((int) local10 < 0 ? local10 : local10 + 72); + local37 = memory.readInt((int) local10 < 0 ? local10 : local10 + 68); + local38 = (local36 + local37); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 32, (int) local38); + local39 = memory.readInt((int) local10 < 0 ? local10 : local10 + 72); + local40 = 1; + local41 = (local39 << local40); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 28, (int) local41); + local42 = 32; + local43 = (local10 + local42); + local44 = local43; + local45 = 28; + local46 = (local10 + local45); + local47 = local46; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local47); + callArgs_3[0] = ((long) local44); + long[] callResult_3 = instance.getMachine().call(1613, callArgs_3); + local48 = ((int) callResult_3[0]); + local49 = memory.readInt((int) local48 < 0 ? local48 : local48 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local49); + long[] callResult_4 = instance.getMachine().call(1614, callArgs_4); + local50 = ((int) callResult_4[0]); + local51 = local50; + break label_2; + } + local52 = memory.readInt((int) local10 < 0 ? local10 : local10 + 44); + local53 = 1; + local54 = (local52 - local53); + local51 = local54; + } + local55 = local51; + memory.writeI32((int) local10 < 0 ? local10 : local10 + 36, (int) local55); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local11); + long[] callResult_5 = instance.getMachine().call(1615, callArgs_5); + local56 = ((int) callResult_5[0]); + local57 = memory.readInt((int) local10 < 0 ? local10 : local10 + 36); + local58 = 1; + local59 = (local57 + local58); + local60 = 16; + local61 = (local10 + local60); + local62 = local61; + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local59); + callArgs_6[1] = ((long) local56); + callArgs_6[0] = ((long) local62); + instance.getMachine().call(1616, callArgs_6); + local63 = memory.readInt((int) local10 < 0 ? local10 : local10 + 16); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 12, (int) local63); + local64 = memory.readInt((int) local10 < 0 ? local10 : local10 + 12); + local65 = memory.readInt((int) local10 < 0 ? local10 : local10 + 20); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local65); + callArgs_7[0] = ((long) local64); + instance.getMachine().call(1617, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local11); + instance.getMachine().call(1618, callArgs_8); + local66 = memory.readInt((int) local10 < 0 ? local10 : local10 + 60); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local66) != 0) { + break label_4; + } + local67 = memory.readInt((int) local10 < 0 ? local10 : local10 + 12); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local67); + long[] callResult_9 = instance.getMachine().call(1595, callArgs_9); + local68 = ((int) callResult_9[0]); + local69 = memory.readInt((int) local10 < 0 ? local10 : local10 + 40); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local69); + long[] callResult_10 = instance.getMachine().call(1595, callArgs_10); + local70 = ((int) callResult_10[0]); + local71 = memory.readInt((int) local10 < 0 ? local10 : local10 + 60); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) local71); + callArgs_11[1] = ((long) local70); + callArgs_11[0] = ((long) local68); + long[] callResult_11 = instance.getMachine().call(1619, callArgs_11); + } + local72 = memory.readInt((int) local10 < 0 ? local10 : local10 + 52); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local72) != 0) { + break label_5; + } + local73 = memory.readInt((int) local10 < 0 ? local10 : local10 + 12); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local73); + long[] callResult_12 = instance.getMachine().call(1595, callArgs_12); + local74 = ((int) callResult_12[0]); + local75 = memory.readInt((int) local10 < 0 ? local10 : local10 + 60); + local76 = (local74 + local75); + local77 = memory.readInt((int) local10 < 0 ? local10 : local10 + 48); + local78 = memory.readInt((int) local10 < 0 ? local10 : local10 + 52); + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) local78); + callArgs_13[1] = ((long) local77); + callArgs_13[0] = ((long) local76); + long[] callResult_13 = instance.getMachine().call(1619, callArgs_13); + } + local79 = memory.readInt((int) local10 < 0 ? local10 : local10 + 64); + local80 = memory.readInt((int) local10 < 0 ? local10 : local10 + 56); + local81 = (local79 - local80); + local82 = memory.readInt((int) local10 < 0 ? local10 : local10 + 60); + local83 = (local81 - local82); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 8, (int) local83); + local84 = memory.readInt((int) local10 < 0 ? local10 : local10 + 8); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local84) != 0) { + break label_6; + } + local85 = memory.readInt((int) local10 < 0 ? local10 : local10 + 12); + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) local85); + long[] callResult_14 = instance.getMachine().call(1595, callArgs_14); + local86 = ((int) callResult_14[0]); + local87 = memory.readInt((int) local10 < 0 ? local10 : local10 + 60); + local88 = (local86 + local87); + local89 = memory.readInt((int) local10 < 0 ? local10 : local10 + 52); + local90 = (local88 + local89); + local91 = memory.readInt((int) local10 < 0 ? local10 : local10 + 40); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local91); + long[] callResult_15 = instance.getMachine().call(1595, callArgs_15); + local92 = ((int) callResult_15[0]); + local93 = memory.readInt((int) local10 < 0 ? local10 : local10 + 60); + local94 = (local92 + local93); + local95 = memory.readInt((int) local10 < 0 ? local10 : local10 + 56); + local96 = (local94 + local95); + local97 = memory.readInt((int) local10 < 0 ? local10 : local10 + 8); + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) local97); + callArgs_16[1] = ((long) local96); + callArgs_16[0] = ((long) local90); + long[] callResult_16 = instance.getMachine().call(1619, callArgs_16); + } + local98 = memory.readInt((int) local10 < 0 ? local10 : local10 + 72); + local99 = 1; + local100 = (local98 + local99); + local101 = 11; + local102 = local100; + local103 = local101; + local104 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local103, local102); + local105 = 1; + local106 = (local104 & local105); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local106) != 0) { + break label_7; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) local11); + long[] callResult_17 = instance.getMachine().call(1615, callArgs_17); + local107 = ((int) callResult_17[0]); + local108 = memory.readInt((int) local10 < 0 ? local10 : local10 + 40); + local109 = memory.readInt((int) local10 < 0 ? local10 : local10 + 72); + local110 = 1; + local111 = (local109 + local110); + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) local111); + callArgs_18[1] = ((long) local108); + callArgs_18[0] = ((long) local107); + instance.getMachine().call(1620, callArgs_18); + } + local112 = memory.readInt((int) local10 < 0 ? local10 : local10 + 12); + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) local112); + callArgs_19[0] = ((long) local11); + instance.getMachine().call(1621, callArgs_19); + local113 = memory.readInt((int) local10 < 0 ? local10 : local10 + 20); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) local113); + callArgs_20[0] = ((long) local11); + instance.getMachine().call(1622, callArgs_20); + local114 = memory.readInt((int) local10 < 0 ? local10 : local10 + 60); + local115 = memory.readInt((int) local10 < 0 ? local10 : local10 + 52); + local116 = (local114 + local115); + local117 = memory.readInt((int) local10 < 0 ? local10 : local10 + 8); + local118 = (local116 + local117); + memory.writeI32((int) local10 < 0 ? local10 : local10 + 64, (int) local118); + local119 = memory.readInt((int) local10 < 0 ? local10 : local10 + 64); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) local119); + callArgs_21[0] = ((long) local11); + instance.getMachine().call(1623, callArgs_21); + local120 = memory.readInt((int) local10 < 0 ? local10 : local10 + 12); + local121 = memory.readInt((int) local10 < 0 ? local10 : local10 + 64); + local122 = (local120 + local121); + local123 = 0; + memory.writeByte((int) local10 < 0 ? local10 : local10 + 7, (byte) (local123)); + local124 = 7; + local125 = (local10 + local124); + local126 = local125; + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) local126); + callArgs_22[0] = ((long) local122); + instance.getMachine().call(1610, callArgs_22); + local127 = 80; + local128 = (local10 + local127); + instance.global(0).setValue(((long) local128)); + return; + } + + public static long[] call_1598(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + int arg7 = ((int) args[7]); + Wat2WasmMachine.func_1598(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, memory, instance); + return null; + } + + public static int func_1599(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1641, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 11) & 0xFF); + local7 = 7; + local8 = (local6 >>> local7); + local9 = 0; + local10 = 255; + local11 = (local8 & local10); + local12 = 255; + local13 = (local9 & local12); + local14 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local13, local11); + local15 = 1; + local16 = (local14 & local15); + local17 = 16; + local18 = (local3 + local17); + instance.global(0).setValue(((long) local18)); + return local16; + } + + public static long[] call_1599(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1599(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1600(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1641, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local7 = 16; + local8 = (local3 + local7); + instance.global(0).setValue(((long) local8)); + return local6; + } + + public static long[] call_1600(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1600(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1601(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1641, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 11) & 0xFF); + local7 = 127; + local8 = (local6 & local7); + local9 = 255; + local10 = (local8 & local9); + local11 = 16; + local12 = (local3 + local11); + instance.global(0).setValue(((long) local12)); + return local10; + } + + public static long[] call_1601(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1601(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1602(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1602(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1602(arg0, memory, instance); + return null; + } + + public static int func_1603(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local7 = 8; + local8 = (local4 + local7); + local9 = local8; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local6); + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1671, callArgs_0); + local10 = ((int) callResult_0[0]); + local11 = 1; + local12 = (local10 & local11); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_2; + } + local13 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local14 = local13; + break label_1; + } + local15 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local14 = local15; + } + local16 = local14; + local17 = 16; + local18 = (local4 + local17); + instance.global(0).setValue(((long) local18)); + return local16; + } + + public static long[] call_1603(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1603(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1604(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1641, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local7 = 2147483647; + local8 = (local6 & local7); + local9 = 0; + local10 = (local8 << local9); + local11 = 16; + local12 = (local3 + local11); + instance.global(0).setValue(((long) local12)); + return local10; + } + + public static long[] call_1604(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1604(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1605(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1633, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local7 = 16; + local8 = (local3 + local7); + instance.global(0).setValue(((long) local8)); + return local6; + } + + public static long[] call_1605(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1605(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1606(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1633, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1634, callArgs_1); + local6 = ((int) callResult_1[0]); + local7 = 16; + local8 = (local3 + local7); + instance.global(0).setValue(((long) local8)); + return local6; + } + + public static long[] call_1606(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1606(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1607(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local9 = 0; + local10 = (local8 << local9); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local10); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + local11 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local12 = 16; + local13 = (local5 + local12); + instance.global(0).setValue(((long) local13)); + return local11; + } + + public static long[] call_1607(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1607(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1608(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1599, callArgs_0); + local6 = ((int) callResult_0[0]); + local7 = 1; + local8 = (local6 & local7); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_2; + } + local9 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local9); + callArgs_1[0] = ((long) local5); + instance.getMachine().call(1623, callArgs_1); + break label_1; + } + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local10); + callArgs_2[0] = ((long) local5); + instance.getMachine().call(1628, callArgs_2); + } + local11 = 16; + local12 = (local4 + local11); + instance.global(0).setValue(((long) local12)); + return; + } + + public static long[] call_1608(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1608(arg0, arg1, memory, instance); + return null; + } + + public static void func_1609(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + return; + } + + public static long[] call_1609(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1609(arg0, arg1, memory, instance); + return null; + } + + public static void func_1610(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local6 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 0, (byte) (local6)); + return; + } + + public static long[] call_1610(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1610(arg0, arg1, memory, instance); + return null; + } + + public static int func_1611(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1629, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1630, callArgs_1); + local6 = ((int) callResult_1[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local6); + local7 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + long[] callResult_2 = instance.getMachine().call(1631, new long[0]); + local8 = ((int) callResult_2[0]); + local9 = 1; + local10 = (local8 >>> local9); + local11 = local7; + local12 = local10; + local13 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local11, local12); + local14 = 1; + local15 = (local13 & local14); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_2; + } + local16 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + local17 = 16; + local18 = (local16 - local17); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local18); + break label_1; + } + local19 = 0; + memory.writeByte((int) local3 < 0 ? local3 : local3 + 3, (byte) (local19)); + local20 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 3) & 0xFF); + local21 = 1; + local22 = (local20 & local21); + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local22) != 0) { + break label_4; + } + local23 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + local24 = 16; + local25 = (local23 - local24); + local26 = local25; + break label_3; + } + local27 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + local28 = 1; + local29 = (local27 >>> local28); + local30 = 16; + local31 = (local29 - local30); + local26 = local31; + } + local32 = local26; + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local32); + } + local33 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local34 = 16; + local35 = (local3 + local34); + instance.global(0).setValue(((long) local35)); + return local33; + } + + public static long[] call_1611(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1611(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1612(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = 14330; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1632, callArgs_0); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1612(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1612(arg0, memory, instance); + return null; + } + + public static int func_1613(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1651, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1613(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1613(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1614(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + local5 = 11; + local6 = local4; + local7 = local5; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local7); + local9 = 1; + local10 = (local8 & local9); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_2; + } + local11 = 10; + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local11); + break label_1; + } + local12 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + local13 = 1; + local14 = (local12 + local13); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local14); + long[] callResult_0 = instance.getMachine().call(1637, callArgs_0); + local15 = ((int) callResult_0[0]); + local16 = 1; + local17 = (local15 - local16); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local17); + local18 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + local19 = 11; + local20 = local18; + local21 = local19; + local22 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local21, local20); + local23 = 1; + local24 = (local22 & local23); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local24) != 0) { + break label_3; + } + local25 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + local26 = 1; + local27 = (local25 + local26); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local27); + } + local28 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local28); + } + local29 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local30 = 16; + local31 = (local3 + local30); + instance.global(0).setValue(((long) local31)); + return local29; + } + + public static long[] call_1614(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1614(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1615(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1636, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1615(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1615(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1616(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1635, callArgs_0); + local8 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local8); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local9); + local10 = 16; + local11 = (local5 + local10); + instance.global(0).setValue(((long) local11)); + return; + } + + public static long[] call_1616(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1616(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_1617(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + return; + } + + public static long[] call_1617(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1617(arg0, arg1, memory, instance); + return null; + } + + public static void func_1618(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + return; + } + + public static long[] call_1618(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1618(arg0, memory, instance); + return null; + } + + public static int func_1619(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local8 = local6; + local9 = local7; + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local8, local9); + local11 = 1; + local12 = 1; + local13 = (local10 & local12); + local14 = local11; + label_1: { + if (local13 != 0) { + break label_1; + } + local15 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local16 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local17 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local18 = (local16 + local17); + local19 = local15; + local20 = local18; + local21 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local19, local20); + local14 = local21; + } + local22 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local23 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local24 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local24); + callArgs_0[1] = ((long) local23); + callArgs_0[0] = ((long) local22); + long[] callResult_0 = instance.getMachine().call(1638, callArgs_0); + local25 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local26 = 16; + local27 = (local5 + local26); + instance.global(0).setValue(((long) local27)); + return local25; + } + + public static long[] call_1619(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1619(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1620(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local8); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + instance.getMachine().call(1642, callArgs_0); + local9 = 16; + local10 = (local5 + local9); + instance.global(0).setValue(((long) local10)); + return; + } + + public static long[] call_1620(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1620(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_1621(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1633, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local6); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return; + } + + public static long[] call_1621(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1621(arg0, arg1, memory, instance); + return null; + } + + public static void func_1622(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = 0; + local8 = (local6 >>> local7); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1633, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 8); + local11 = 2147483647; + local12 = (local8 & local11); + local13 = -2147483648; + local14 = (local10 & local13); + local15 = (local14 | local12); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 8, (int) local15); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1633, callArgs_1); + local16 = ((int) callResult_1[0]); + local17 = memory.readInt((int) local16 < 0 ? local16 : local16 + 8); + local18 = 2147483647; + local19 = (local17 & local18); + local20 = -2147483648; + local21 = (local19 | local20); + memory.writeI32((int) local16 < 0 ? local16 : local16 + 8, (int) local21); + local22 = 16; + local23 = (local4 + local22); + instance.global(0).setValue(((long) local23)); + return; + } + + public static long[] call_1622(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1622(arg0, arg1, memory, instance); + return null; + } + + public static void func_1623(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1633, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 4, (int) local6); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return; + } + + public static long[] call_1623(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1623(arg0, arg1, memory, instance); + return null; + } + + public static int func_1624(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1625, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1626, callArgs_1); + local6 = ((int) callResult_1[0]); + local7 = 16; + local8 = (local3 + local7); + instance.global(0).setValue(((long) local8)); + return local6; + } + + public static long[] call_1624(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1624(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1625(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1599, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 1; + local7 = (local5 & local6); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1672, callArgs_1); + local8 = ((int) callResult_1[0]); + local9 = local8; + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(1673, callArgs_2); + local10 = ((int) callResult_2[0]); + local9 = local10; + } + local11 = local9; + local12 = 16; + local13 = (local3 + local12); + instance.global(0).setValue(((long) local13)); + return local11; + } + + public static long[] call_1625(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1625(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1626(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1626(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1626(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1627(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = 11; + local6 = local4; + local7 = local5; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local7); + local9 = 1; + local10 = (local8 & local9); + return local10; + } + + public static long[] call_1627(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1627(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1628(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 8) & 0xFF); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1633, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 11) & 0xFF); + local9 = 127; + local10 = (local6 & local9); + local11 = 128; + local12 = (local8 & local11); + local13 = (local12 | local10); + memory.writeByte((int) local7 < 0 ? local7 : local7 + 11, (byte) (local13)); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1633, callArgs_1); + local14 = ((int) callResult_1[0]); + local15 = ((int) memory.read((int) local14 < 0 ? local14 : local14 + 11) & 0xFF); + local16 = (local15 & local9); + memory.writeByte((int) local14 < 0 ? local14 : local14 + 11, (byte) (local16)); + local17 = 16; + local18 = (local4 + local17); + instance.global(0).setValue(((long) local18)); + return; + } + + public static long[] call_1628(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1628(arg0, arg1, memory, instance); + return null; + } + + public static int func_1629(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1676, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1629(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1629(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1630(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + long[] callResult_0 = instance.getMachine().call(1631, new long[0]); + local4 = ((int) callResult_0[0]); + local5 = 0; + local6 = (local4 >>> local5); + local7 = 16; + local8 = (local3 + local7); + instance.global(0).setValue(((long) local8)); + return local6; + } + + public static long[] call_1630(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1630(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1631(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + long[] callResult_0 = instance.getMachine().call(1677, new long[0]); + local0 = ((int) callResult_0[0]); + return local0; + } + + public static long[] call_1631(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int result = Wat2WasmMachine.func_1631(memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1632(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1632(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1632(arg0, memory, instance); + return null; + } + + public static int func_1633(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1679, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1633(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1633(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1634(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1634(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1634(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1635(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1630, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = local6; + local9 = local7; + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local9); + local11 = 1; + local12 = (local10 & local11); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_1; + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local13 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local14 = 0; + local15 = (local13 << local14); + local16 = 1; + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local16); + callArgs_2[0] = ((long) local15); + long[] callResult_2 = instance.getMachine().call(1680, callArgs_2); + local17 = ((int) callResult_2[0]); + local18 = 16; + local19 = (local4 + local18); + instance.global(0).setValue(((long) local19)); + return local17; + } + + public static long[] call_1635(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1635(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1636(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1684, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1636(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1636(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1637(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = 15; + local6 = (local4 + local5); + local7 = -16; + local8 = (local6 & local7); + return local8; + } + + public static long[] call_1637(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1637(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1638(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local10 = (local8 + local9); + local11 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local11); + callArgs_0[1] = ((long) local10); + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1685, callArgs_0); + local12 = ((int) callResult_0[0]); + local13 = 16; + local14 = (local5 + local13); + instance.global(0).setValue(((long) local14)); + return local12; + } + + public static long[] call_1638(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1638(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1639(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1640, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1639(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1639(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1640(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1640(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1640(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1641(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1675, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1641(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1641(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1642(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local8 = 0; + local9 = (local7 << local8); + local10 = 1; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local10); + callArgs_0[1] = ((long) local9); + callArgs_0[0] = ((long) local6); + instance.getMachine().call(1708, callArgs_0); + local11 = 16; + local12 = (local5 + local11); + instance.global(0).setValue(((long) local12)); + return; + } + + public static long[] call_1642(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1642(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_1643(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + int local84 = 0; + int local85 = 0; + int local86 = 0; + int local87 = 0; + int local88 = 0; + int local89 = 0; + int local90 = 0; + int local91 = 0; + int local92 = 0; + int local93 = 0; + int local94 = 0; + int local95 = 0; + int local96 = 0; + int local97 = 0; + int local98 = 0; + int local99 = 0; + int local100 = 0; + int local101 = 0; + int local102 = 0; + int local103 = 0; + int local104 = 0; + int local105 = 0; + local7 = ((int) instance.global(0).getValue()); + local8 = 64; + local9 = (local7 - local8); + instance.global(0).setValue(((long) local9)); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 60, (int) arg0); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 56, (int) arg1); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 52, (int) arg2); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 48, (int) arg3); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 44, (int) arg4); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 40, (int) arg5); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 36, (int) arg6); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 60); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local10); + long[] callResult_0 = instance.getMachine().call(1611, callArgs_0); + local11 = ((int) callResult_0[0]); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 32, (int) local11); + local12 = memory.readInt((int) local9 < 0 ? local9 : local9 + 52); + local13 = memory.readInt((int) local9 < 0 ? local9 : local9 + 32); + local14 = memory.readInt((int) local9 < 0 ? local9 : local9 + 56); + local15 = (local13 - local14); + local16 = local12; + local17 = local15; + local18 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local16, local17); + local19 = 1; + local20 = (local18 & local19); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local20) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local10); + instance.getMachine().call(1612, callArgs_1); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local10); + long[] callResult_2 = instance.getMachine().call(1594, callArgs_2); + local21 = ((int) callResult_2[0]); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 28, (int) local21); + local22 = memory.readInt((int) local9 < 0 ? local9 : local9 + 56); + local23 = memory.readInt((int) local9 < 0 ? local9 : local9 + 32); + local24 = 1; + local25 = (local23 >>> local24); + local26 = 16; + local27 = (local25 - local26); + local28 = local22; + local29 = local27; + local30 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local28, local29); + local31 = 1; + local32 = (local30 & local31); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local32) != 0) { + break label_3; + } + local33 = memory.readInt((int) local9 < 0 ? local9 : local9 + 56); + local34 = memory.readInt((int) local9 < 0 ? local9 : local9 + 52); + local35 = (local33 + local34); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 20, (int) local35); + local36 = memory.readInt((int) local9 < 0 ? local9 : local9 + 56); + local37 = 1; + local38 = (local36 << local37); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 16, (int) local38); + local39 = 20; + local40 = (local9 + local39); + local41 = local40; + local42 = 16; + local43 = (local9 + local42); + local44 = local43; + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local44); + callArgs_3[0] = ((long) local41); + long[] callResult_3 = instance.getMachine().call(1613, callArgs_3); + local45 = ((int) callResult_3[0]); + local46 = memory.readInt((int) local45 < 0 ? local45 : local45 + 0); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local46); + long[] callResult_4 = instance.getMachine().call(1614, callArgs_4); + local47 = ((int) callResult_4[0]); + local48 = local47; + break label_2; + } + local49 = memory.readInt((int) local9 < 0 ? local9 : local9 + 32); + local50 = 1; + local51 = (local49 - local50); + local48 = local51; + } + local52 = local48; + memory.writeI32((int) local9 < 0 ? local9 : local9 + 24, (int) local52); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local10); + long[] callResult_5 = instance.getMachine().call(1615, callArgs_5); + local53 = ((int) callResult_5[0]); + local54 = memory.readInt((int) local9 < 0 ? local9 : local9 + 24); + local55 = 1; + local56 = (local54 + local55); + local57 = 8; + local58 = (local9 + local57); + local59 = local58; + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local56); + callArgs_6[1] = ((long) local53); + callArgs_6[0] = ((long) local59); + instance.getMachine().call(1616, callArgs_6); + local60 = memory.readInt((int) local9 < 0 ? local9 : local9 + 8); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 4, (int) local60); + local61 = memory.readInt((int) local9 < 0 ? local9 : local9 + 4); + local62 = memory.readInt((int) local9 < 0 ? local9 : local9 + 12); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local62); + callArgs_7[0] = ((long) local61); + instance.getMachine().call(1617, callArgs_7); + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local10); + instance.getMachine().call(1618, callArgs_8); + local63 = memory.readInt((int) local9 < 0 ? local9 : local9 + 44); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local63) != 0) { + break label_4; + } + local64 = memory.readInt((int) local9 < 0 ? local9 : local9 + 4); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local64); + long[] callResult_9 = instance.getMachine().call(1595, callArgs_9); + local65 = ((int) callResult_9[0]); + local66 = memory.readInt((int) local9 < 0 ? local9 : local9 + 28); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local66); + long[] callResult_10 = instance.getMachine().call(1595, callArgs_10); + local67 = ((int) callResult_10[0]); + local68 = memory.readInt((int) local9 < 0 ? local9 : local9 + 44); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) local68); + callArgs_11[1] = ((long) local67); + callArgs_11[0] = ((long) local65); + long[] callResult_11 = instance.getMachine().call(1619, callArgs_11); + } + local69 = memory.readInt((int) local9 < 0 ? local9 : local9 + 48); + local70 = memory.readInt((int) local9 < 0 ? local9 : local9 + 40); + local71 = (local69 - local70); + local72 = memory.readInt((int) local9 < 0 ? local9 : local9 + 44); + local73 = (local71 - local72); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) local73); + local74 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local74) != 0) { + break label_5; + } + local75 = memory.readInt((int) local9 < 0 ? local9 : local9 + 4); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local75); + long[] callResult_12 = instance.getMachine().call(1595, callArgs_12); + local76 = ((int) callResult_12[0]); + local77 = memory.readInt((int) local9 < 0 ? local9 : local9 + 44); + local78 = (local76 + local77); + local79 = memory.readInt((int) local9 < 0 ? local9 : local9 + 36); + local80 = (local78 + local79); + local81 = memory.readInt((int) local9 < 0 ? local9 : local9 + 28); + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) local81); + long[] callResult_13 = instance.getMachine().call(1595, callArgs_13); + local82 = ((int) callResult_13[0]); + local83 = memory.readInt((int) local9 < 0 ? local9 : local9 + 44); + local84 = (local82 + local83); + local85 = memory.readInt((int) local9 < 0 ? local9 : local9 + 40); + local86 = (local84 + local85); + local87 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) local87); + callArgs_14[1] = ((long) local86); + callArgs_14[0] = ((long) local80); + long[] callResult_14 = instance.getMachine().call(1619, callArgs_14); + } + local88 = memory.readInt((int) local9 < 0 ? local9 : local9 + 56); + local89 = 1; + local90 = (local88 + local89); + local91 = 11; + local92 = local90; + local93 = local91; + local94 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local93, local92); + local95 = 1; + local96 = (local94 & local95); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local96) != 0) { + break label_6; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) local10); + long[] callResult_15 = instance.getMachine().call(1615, callArgs_15); + local97 = ((int) callResult_15[0]); + local98 = memory.readInt((int) local9 < 0 ? local9 : local9 + 28); + local99 = memory.readInt((int) local9 < 0 ? local9 : local9 + 56); + local100 = 1; + local101 = (local99 + local100); + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) local101); + callArgs_16[1] = ((long) local98); + callArgs_16[0] = ((long) local97); + instance.getMachine().call(1620, callArgs_16); + } + local102 = memory.readInt((int) local9 < 0 ? local9 : local9 + 4); + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) local102); + callArgs_17[0] = ((long) local10); + instance.getMachine().call(1621, callArgs_17); + local103 = memory.readInt((int) local9 < 0 ? local9 : local9 + 12); + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) local103); + callArgs_18[0] = ((long) local10); + instance.getMachine().call(1622, callArgs_18); + local104 = 64; + local105 = (local9 + local104); + instance.global(0).setValue(((long) local105)); + return; + } + + public static long[] call_1643(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + int arg6 = ((int) args[6]); + Wat2WasmMachine.func_1643(arg0, arg1, arg2, arg3, arg4, arg5, arg6, memory, instance); + return null; + } + + public static int func_1644(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 7, (byte) (arg2)); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local8 = 7; + local9 = (local5 + local8); + local10 = local9; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local10); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1645, callArgs_0); + local11 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local12 = 16; + local13 = (local5 + local12); + instance.global(0).setValue(((long) local13)); + return local11; + } + + public static long[] call_1644(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1644(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1645(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1713, callArgs_0); + local8 = ((int) callResult_0[0]); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local9); + callArgs_1[1] = ((long) local8); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1714, callArgs_1); + local10 = ((int) callResult_1[0]); + local11 = 16; + local12 = (local5 + local11); + instance.global(0).setValue(((long) local12)); + return local10; + } + + public static long[] call_1645(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1645(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1646(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1611, callArgs_0); + local8 = ((int) callResult_0[0]); + local9 = local7; + local10 = local8; + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local9, local10); + local12 = 1; + local13 = (local11 & local12); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local13) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + instance.getMachine().call(1612, callArgs_1); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local14 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local14); + long[] callResult_2 = instance.getMachine().call(1627, callArgs_2); + local15 = ((int) callResult_2[0]); + local16 = 1; + local17 = (local15 & local16); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local17) != 0) { + break label_3; + } + local18 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local18); + callArgs_3[0] = ((long) local6); + instance.getMachine().call(1628, callArgs_3); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1606, callArgs_4); + local19 = ((int) callResult_4[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local19); + break label_2; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(1615, callArgs_5); + local20 = ((int) callResult_5[0]); + local21 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local21); + long[] callResult_6 = instance.getMachine().call(1614, callArgs_6); + local22 = ((int) callResult_6[0]); + local23 = 1; + local24 = (local22 + local23); + local25 = 8; + local26 = (local5 + local25); + local27 = local26; + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local24); + callArgs_7[1] = ((long) local20); + callArgs_7[0] = ((long) local27); + instance.getMachine().call(1616, callArgs_7); + local28 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local28); + local29 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local30 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local30); + callArgs_8[0] = ((long) local29); + instance.getMachine().call(1617, callArgs_8); + local31 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local31); + callArgs_9[0] = ((long) local6); + instance.getMachine().call(1621, callArgs_9); + local32 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) local32); + callArgs_10[0] = ((long) local6); + instance.getMachine().call(1622, callArgs_10); + local33 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) local33); + callArgs_11[0] = ((long) local6); + instance.getMachine().call(1623, callArgs_11); + } + local34 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local34); + long[] callResult_12 = instance.getMachine().call(1595, callArgs_12); + local35 = ((int) callResult_12[0]); + local36 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local37 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) local37); + callArgs_13[1] = ((long) local36); + callArgs_13[0] = ((long) local35); + long[] callResult_13 = instance.getMachine().call(1619, callArgs_13); + local38 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local39 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local40 = (local38 + local39); + local41 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 7, (byte) (local41)); + local42 = 7; + local43 = (local5 + local42); + local44 = local43; + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) local44); + callArgs_14[0] = ((long) local40); + instance.getMachine().call(1610, callArgs_14); + local45 = 32; + local46 = (local5 + local45); + instance.global(0).setValue(((long) local46)); + return; + } + + public static long[] call_1646(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1646(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_1647(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1627, callArgs_0); + local8 = ((int) callResult_0[0]); + local9 = 1; + local10 = (local8 & local9); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local10) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1606, callArgs_1); + local11 = ((int) callResult_1[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local11); + local12 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local12); + callArgs_2[0] = ((long) local6); + instance.getMachine().call(1628, callArgs_2); + break label_1; + } + local13 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(1611, callArgs_3); + local14 = ((int) callResult_3[0]); + local15 = local13; + local16 = local14; + local17 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local15, local16); + local18 = 1; + local19 = (local17 & local18); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local19) != 0) { + break label_3; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local6); + instance.getMachine().call(1612, callArgs_4); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(1615, callArgs_5); + local20 = ((int) callResult_5[0]); + local21 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local21); + long[] callResult_6 = instance.getMachine().call(1614, callArgs_6); + local22 = ((int) callResult_6[0]); + local23 = 1; + local24 = (local22 + local23); + local25 = 8; + local26 = (local5 + local25); + local27 = local26; + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local24); + callArgs_7[1] = ((long) local20); + callArgs_7[0] = ((long) local27); + instance.getMachine().call(1616, callArgs_7); + local28 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local28); + local29 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local30 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local30); + callArgs_8[0] = ((long) local29); + instance.getMachine().call(1617, callArgs_8); + local31 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local31); + callArgs_9[0] = ((long) local6); + instance.getMachine().call(1621, callArgs_9); + local32 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) local32); + callArgs_10[0] = ((long) local6); + instance.getMachine().call(1622, callArgs_10); + local33 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) local33); + callArgs_11[0] = ((long) local6); + instance.getMachine().call(1623, callArgs_11); + } + local34 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) local34); + long[] callResult_12 = instance.getMachine().call(1595, callArgs_12); + local35 = ((int) callResult_12[0]); + local36 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local37 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local38 = 1; + local39 = (local37 + local38); + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) local39); + callArgs_13[1] = ((long) local36); + callArgs_13[0] = ((long) local35); + long[] callResult_13 = instance.getMachine().call(1619, callArgs_13); + local40 = 32; + local41 = (local5 + local40); + instance.global(0).setValue(((long) local41)); + return; + } + + public static long[] call_1647(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1647(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1648(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + int local84 = 0; + int local85 = 0; + int local86 = 0; + int local87 = 0; + int local88 = 0; + int local89 = 0; + int local90 = 0; + int local91 = 0; + int local92 = 0; + int local93 = 0; + int local94 = 0; + int local95 = 0; + int local96 = 0; + int local97 = 0; + int local98 = 0; + int local99 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 48; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 44, (int) arg0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 40, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 36, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 44); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + local9 = 1; + local10 = local9; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_1; + } + local11 = memory.readInt((int) local6 < 0 ? local6 : local6 + 36); + local12 = 0; + local13 = local11; + local14 = local12; + local15 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local14, local13); + local10 = local15; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1590, callArgs_0); + local16 = ((int) callResult_0[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 28, (int) local16); + local17 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + local18 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local19 = local17; + local20 = local18; + local21 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local19, local20); + local22 = 1; + local23 = (local21 & local22); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local23) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local7); + instance.getMachine().call(1591, callArgs_1); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local7); + long[] callResult_2 = instance.getMachine().call(1593, callArgs_2); + local24 = ((int) callResult_2[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) local24); + local25 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local26 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local27 = (local25 - local26); + local28 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + local29 = local27; + local30 = local28; + local31 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local29, local30); + local32 = 1; + local33 = (local31 & local32); + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local33) != 0) { + break label_4; + } + local34 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local34) != 0) { + break label_5; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local7); + long[] callResult_3 = instance.getMachine().call(1594, callArgs_3); + local35 = ((int) callResult_3[0]); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local35); + long[] callResult_4 = instance.getMachine().call(1595, callArgs_4); + local36 = ((int) callResult_4[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) local36); + local37 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local38 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + local39 = (local37 - local38); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) local39); + local40 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local40) != 0) { + break label_6; + } + local41 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local42 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + local43 = (local41 + local42); + local44 = memory.readInt((int) local6 < 0 ? local6 : local6 + 36); + local45 = local43; + local46 = local44; + local47 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local45, local46); + local48 = 1; + local49 = (local47 & local48); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local49) != 0) { + break label_7; + } + local50 = memory.readInt((int) local6 < 0 ? local6 : local6 + 36); + local51 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local52 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local53 = (local51 + local52); + local54 = local50; + local55 = local53; + local56 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local54, local55); + local57 = 1; + local58 = (local56 & local57); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local58) != 0) { + break label_7; + } + local59 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + local60 = memory.readInt((int) local6 < 0 ? local6 : local6 + 36); + local61 = (local60 + local59); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 36, (int) local61); + } + local62 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local63 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + local64 = (local62 + local63); + local65 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + local66 = (local64 + local65); + local67 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local68 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + local69 = (local67 + local68); + local70 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local70); + callArgs_5[1] = ((long) local69); + callArgs_5[0] = ((long) local66); + long[] callResult_5 = instance.getMachine().call(1596, callArgs_5); + } + local71 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local72 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + local73 = (local71 + local72); + local74 = memory.readInt((int) local6 < 0 ? local6 : local6 + 36); + local75 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) local75); + callArgs_6[1] = ((long) local74); + callArgs_6[0] = ((long) local73); + long[] callResult_6 = instance.getMachine().call(1596, callArgs_6); + local76 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + local77 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local78 = (local77 + local76); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 28, (int) local78); + local79 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local79); + callArgs_7[0] = ((long) local7); + instance.getMachine().call(1608, callArgs_7); + local80 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local81 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local82 = (local80 + local81); + local83 = 0; + memory.writeByte((int) local6 < 0 ? local6 : local6 + 15, (byte) (local83)); + local84 = 15; + local85 = (local6 + local84); + local86 = local85; + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local86); + callArgs_8[0] = ((long) local82); + instance.getMachine().call(1610, callArgs_8); + } + break label_3; + } + local87 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local88 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local89 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + local90 = (local88 + local89); + local91 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local92 = (local90 - local91); + local93 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local94 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + local95 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + local96 = memory.readInt((int) local6 < 0 ? local6 : local6 + 36); + local97 = 0; + long[] callArgs_9 = new long[8]; + callArgs_9[7] = ((long) local96); + callArgs_9[6] = ((long) local95); + callArgs_9[5] = ((long) local97); + callArgs_9[4] = ((long) local94); + callArgs_9[3] = ((long) local93); + callArgs_9[2] = ((long) local92); + callArgs_9[1] = ((long) local87); + callArgs_9[0] = ((long) local7); + instance.getMachine().call(1598, callArgs_9); + } + local98 = 48; + local99 = (local6 + local98); + instance.global(0).setValue(((long) local99)); + return local7; + } + + public static long[] call_1648(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1648(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1649(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1593, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local7); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local10 = local8; + local11 = local9; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local10, local11); + local13 = 1; + local14 = (local12 & local13); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local14) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1594, callArgs_1); + local15 = ((int) callResult_1[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local15); + long[] callResult_2 = instance.getMachine().call(1595, callArgs_2); + local16 = ((int) callResult_2[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local16); + local17 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local18 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local19 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local19); + callArgs_3[1] = ((long) local18); + callArgs_3[0] = ((long) local17); + long[] callResult_3 = instance.getMachine().call(1596, callArgs_3); + local20 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local21 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local21); + callArgs_4[1] = ((long) local20); + callArgs_4[0] = ((long) local6); + long[] callResult_4 = instance.getMachine().call(1597, callArgs_4); + local22 = ((int) callResult_4[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) local22); + break label_1; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(1590, callArgs_5); + local23 = ((int) callResult_5[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local23); + local24 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local25 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local26 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local27 = (local25 - local26); + local28 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local29 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local30 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local31 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local32 = 0; + long[] callArgs_6 = new long[8]; + callArgs_6[7] = ((long) local31); + callArgs_6[6] = ((long) local30); + callArgs_6[5] = ((long) local29); + callArgs_6[4] = ((long) local32); + callArgs_6[3] = ((long) local28); + callArgs_6[2] = ((long) local27); + callArgs_6[1] = ((long) local24); + callArgs_6[0] = ((long) local6); + instance.getMachine().call(1598, callArgs_6); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) local6); + } + local33 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local34 = 32; + local35 = (local5 + local34); + instance.global(0).setValue(((long) local35)); + return local33; + } + + public static long[] call_1649(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1649(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1650(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1639, callArgs_0); + local8 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local8); + callArgs_1[1] = ((long) local6); + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1649, callArgs_1); + local9 = ((int) callResult_1[0]); + local10 = 16; + local11 = (local4 + local10); + instance.global(0).setValue(((long) local11)); + return local9; + } + + public static long[] call_1650(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1650(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1651(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local7 = 8; + local8 = (local4 + local7); + local9 = local8; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local6); + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1671, callArgs_0); + local10 = ((int) callResult_0[0]); + local11 = 1; + local12 = (local10 & local11); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_2; + } + local13 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local14 = local13; + break label_1; + } + local15 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local14 = local15; + } + local16 = local14; + local17 = 16; + local18 = (local4 + local17); + instance.global(0).setValue(((long) local18)); + return local16; + } + + public static long[] call_1651(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1651(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1652(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local8 = 1; + local9 = local8; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_1; + } + local10 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local11 = 0; + local12 = local10; + local13 = local11; + local14 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local13, local12); + local9 = local14; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1593, callArgs_0); + local15 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local15); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1590, callArgs_1); + local16 = ((int) callResult_1[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local16); + local17 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local18 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local19 = (local17 - local18); + local20 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local21 = local19; + local22 = local20; + local23 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local21, local22); + local24 = 1; + local25 = (local23 & local24); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local25) != 0) { + break label_3; + } + local26 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local26) != 0) { + break label_4; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + long[] callResult_2 = instance.getMachine().call(1594, callArgs_2); + local27 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local27); + long[] callResult_3 = instance.getMachine().call(1595, callArgs_3); + local28 = ((int) callResult_3[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local28); + local29 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local30 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local31 = (local29 + local30); + local32 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local33 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local33); + callArgs_4[1] = ((long) local32); + callArgs_4[0] = ((long) local31); + long[] callResult_4 = instance.getMachine().call(1619, callArgs_4); + local34 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local35 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local36 = (local35 + local34); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local36); + local37 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local37); + callArgs_5[0] = ((long) local6); + instance.getMachine().call(1608, callArgs_5); + local38 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local39 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local40 = (local38 + local39); + local41 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 7, (byte) (local41)); + local42 = 7; + local43 = (local5 + local42); + local44 = local43; + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local44); + callArgs_6[0] = ((long) local40); + instance.getMachine().call(1610, callArgs_6); + } + break label_2; + } + local45 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local46 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local47 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local48 = (local46 + local47); + local49 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local50 = (local48 - local49); + local51 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local52 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local53 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local54 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local55 = 0; + long[] callArgs_7 = new long[8]; + callArgs_7[7] = ((long) local54); + callArgs_7[6] = ((long) local53); + callArgs_7[5] = ((long) local55); + callArgs_7[4] = ((long) local52); + callArgs_7[3] = ((long) local51); + callArgs_7[2] = ((long) local50); + callArgs_7[1] = ((long) local45); + callArgs_7[0] = ((long) local6); + instance.getMachine().call(1598, callArgs_7); + } + local56 = 32; + local57 = (local5 + local56); + instance.global(0).setValue(((long) local57)); + return local6; + } + + public static long[] call_1652(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1652(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1653(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + local5 = ((int) instance.global(0).getValue()); + local6 = 32; + local7 = (local5 - local6); + instance.global(0).setValue(((long) local7)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) arg0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 24, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 20, (int) arg2); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 16, (int) arg3); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) arg4); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 28); + local9 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local10 = 8; + local11 = (local7 + local10); + local12 = local11; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local9); + callArgs_0[1] = ((long) local12); + callArgs_0[0] = ((long) local8); + long[] callResult_0 = instance.getMachine().call(1654, callArgs_0); + local13 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local13); + long[] callResult_1 = instance.getMachine().call(1590, callArgs_1); + local14 = ((int) callResult_1[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 4, (int) local14); + local15 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local16 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + local17 = local15; + local18 = local16; + local19 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local17, local18); + local20 = 1; + local21 = (local19 & local20); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local21) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local8); + instance.getMachine().call(1591, callArgs_2); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local22 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local22); + long[] callResult_3 = instance.getMachine().call(1624, callArgs_3); + local23 = ((int) callResult_3[0]); + local24 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local25 = (local23 + local24); + local26 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + local27 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local28 = (local26 - local27); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) local28); + local29 = 16; + local30 = (local7 + local29); + local31 = local30; + local32 = local7; + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local32); + callArgs_4[0] = ((long) local31); + long[] callResult_4 = instance.getMachine().call(1592, callArgs_4); + local33 = ((int) callResult_4[0]); + local34 = memory.readInt((int) local33 < 0 ? local33 : local33 + 0); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local34); + callArgs_5[1] = ((long) local25); + callArgs_5[0] = ((long) local8); + instance.getMachine().call(1646, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local8); + instance.getMachine().call(1655, callArgs_6); + local35 = 32; + local36 = (local7 + local35); + instance.global(0).setValue(((long) local36)); + return local8; + } + + public static long[] call_1653(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1653(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1654(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1656, callArgs_0); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local7); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1657, callArgs_1); + local8 = 16; + local9 = (local5 + local8); + instance.global(0).setValue(((long) local9)); + return local6; + } + + public static long[] call_1654(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1654(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1655(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + return; + } + + public static long[] call_1655(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1655(arg0, memory, instance); + return null; + } + + public static int func_1656(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + return local4; + } + + public static long[] call_1656(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1656(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1657(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + return local5; + } + + public static long[] call_1657(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1657(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1658(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1604, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local7); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local10 = local8; + local11 = local9; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, local11); + local13 = 1; + local14 = (local12 & local13); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local14) != 0) { + break label_2; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1605, callArgs_1); + local15 = ((int) callResult_1[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local15); + local16 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local16); + callArgs_2[0] = ((long) local6); + instance.getMachine().call(1623, callArgs_2); + local17 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local17); + long[] callResult_3 = instance.getMachine().call(1595, callArgs_3); + local18 = ((int) callResult_3[0]); + local19 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local20 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) local20); + callArgs_4[1] = ((long) local19); + callArgs_4[0] = ((long) local18); + long[] callResult_4 = instance.getMachine().call(1619, callArgs_4); + local21 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local22 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local23 = (local21 + local22); + local24 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 11, (byte) (local24)); + local25 = 11; + local26 = (local5 + local25); + local27 = local26; + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local27); + callArgs_5[0] = ((long) local23); + instance.getMachine().call(1610, callArgs_5); + local28 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local28); + callArgs_6[0] = ((long) local6); + instance.getMachine().call(1609, callArgs_6); + break label_1; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local6); + long[] callResult_7 = instance.getMachine().call(1600, callArgs_7); + local29 = ((int) callResult_7[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local29); + local30 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local31 = 1; + local32 = (local30 - local31); + local33 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local34 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local35 = (local33 - local34); + local36 = 1; + local37 = (local35 + local36); + local38 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local39 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local40 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local41 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local42 = 0; + long[] callArgs_8 = new long[8]; + callArgs_8[7] = ((long) local41); + callArgs_8[6] = ((long) local40); + callArgs_8[5] = ((long) local39); + callArgs_8[4] = ((long) local42); + callArgs_8[3] = ((long) local38); + callArgs_8[2] = ((long) local37); + callArgs_8[1] = ((long) local32); + callArgs_8[0] = ((long) local6); + instance.getMachine().call(1598, callArgs_8); + } + local43 = 32; + local44 = (local5 + local43); + instance.global(0).setValue(((long) local44)); + return local6; + } + + public static long[] call_1658(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1658(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1659(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local7 = 11; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local7); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local10 = local8; + local11 = local9; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, local11); + local13 = 1; + local14 = (local12 & local13); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local14) != 0) { + break label_2; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1606, callArgs_0); + local15 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local15); + local16 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local16); + callArgs_1[0] = ((long) local6); + instance.getMachine().call(1628, callArgs_1); + local17 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local17); + long[] callResult_2 = instance.getMachine().call(1595, callArgs_2); + local18 = ((int) callResult_2[0]); + local19 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local20 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local20); + callArgs_3[1] = ((long) local19); + callArgs_3[0] = ((long) local18); + long[] callResult_3 = instance.getMachine().call(1619, callArgs_3); + local21 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local22 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local23 = (local21 + local22); + local24 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 11, (byte) (local24)); + local25 = 11; + local26 = (local5 + local25); + local27 = local26; + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local27); + callArgs_4[0] = ((long) local23); + instance.getMachine().call(1610, callArgs_4); + local28 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local28); + callArgs_5[0] = ((long) local6); + instance.getMachine().call(1609, callArgs_5); + break label_1; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local6); + long[] callResult_6 = instance.getMachine().call(1601, callArgs_6); + local29 = ((int) callResult_6[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local29); + local30 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local31 = 1; + local32 = (local30 - local31); + local33 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local34 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local35 = (local33 - local34); + local36 = 1; + local37 = (local35 + local36); + local38 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local39 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local40 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local41 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local42 = 0; + long[] callArgs_7 = new long[8]; + callArgs_7[7] = ((long) local41); + callArgs_7[6] = ((long) local40); + callArgs_7[5] = ((long) local39); + callArgs_7[4] = ((long) local42); + callArgs_7[3] = ((long) local38); + callArgs_7[2] = ((long) local37); + callArgs_7[1] = ((long) local32); + callArgs_7[0] = ((long) local6); + instance.getMachine().call(1598, callArgs_7); + } + local43 = 32; + local44 = (local5 + local43); + instance.global(0).setValue(((long) local44)); + return local6; + } + + public static long[] call_1659(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1659(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1660(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 32; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) arg0); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 27, (byte) (arg1)); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 28); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1599, callArgs_0); + local6 = ((int) callResult_0[0]); + local7 = -1; + local8 = (local6 ^ local7); + local9 = 1; + local10 = (local8 & local9); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 26, (byte) (local10)); + local11 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 26) & 0xFF); + local12 = 1; + local13 = (local11 & local12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local13) != 0) { + break label_2; + } + local14 = 10; + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) local14); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1601, callArgs_1); + local15 = ((int) callResult_1[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) local15); + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local5); + long[] callResult_2 = instance.getMachine().call(1604, callArgs_2); + local16 = ((int) callResult_2[0]); + local17 = 1; + local18 = (local16 - local17); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) local18); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local5); + long[] callResult_3 = instance.getMachine().call(1600, callArgs_3); + local19 = ((int) callResult_3[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 16, (int) local19); + } + local20 = memory.readInt((int) local4 < 0 ? local4 : local4 + 16); + local21 = memory.readInt((int) local4 < 0 ? local4 : local4 + 20); + local22 = local20; + local23 = local21; + local24 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local23, local22); + local25 = 1; + local26 = (local24 & local25); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local26) != 0) { + break label_3; + } + local27 = memory.readInt((int) local4 < 0 ? local4 : local4 + 20); + local28 = memory.readInt((int) local4 < 0 ? local4 : local4 + 16); + local29 = memory.readInt((int) local4 < 0 ? local4 : local4 + 16); + local30 = 1; + local31 = 0; + long[] callArgs_4 = new long[7]; + callArgs_4[6] = ((long) local31); + callArgs_4[5] = ((long) local31); + callArgs_4[4] = ((long) local29); + callArgs_4[3] = ((long) local28); + callArgs_4[2] = ((long) local30); + callArgs_4[1] = ((long) local27); + callArgs_4[0] = ((long) local5); + instance.getMachine().call(1643, callArgs_4); + local32 = 0; + memory.writeByte((int) local4 < 0 ? local4 : local4 + 26, (byte) (local32)); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local5); + long[] callResult_5 = instance.getMachine().call(1594, callArgs_5); + local33 = ((int) callResult_5[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local33); + local34 = ((int) memory.read((int) local4 < 0 ? local4 : local4 + 26) & 0xFF); + local35 = 1; + local36 = (local34 & local35); + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local36) != 0) { + break label_5; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local5); + long[] callResult_6 = instance.getMachine().call(1606, callArgs_6); + local37 = ((int) callResult_6[0]); + local38 = memory.readInt((int) local4 < 0 ? local4 : local4 + 16); + local39 = (local37 + local38); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local39); + local40 = memory.readInt((int) local4 < 0 ? local4 : local4 + 16); + local41 = 1; + local42 = (local40 + local41); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local42); + callArgs_7[0] = ((long) local5); + instance.getMachine().call(1628, callArgs_7); + break label_4; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local5); + long[] callResult_8 = instance.getMachine().call(1605, callArgs_8); + local43 = ((int) callResult_8[0]); + local44 = memory.readInt((int) local4 < 0 ? local4 : local4 + 16); + local45 = (local43 + local44); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local45); + local46 = memory.readInt((int) local4 < 0 ? local4 : local4 + 16); + local47 = 1; + local48 = (local46 + local47); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local48); + callArgs_9[0] = ((long) local5); + instance.getMachine().call(1623, callArgs_9); + } + local49 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local50 = 27; + local51 = (local4 + local50); + local52 = local51; + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) local52); + callArgs_10[0] = ((long) local49); + instance.getMachine().call(1610, callArgs_10); + local53 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local54 = 1; + local55 = (local53 + local54); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local55); + local56 = 0; + memory.writeByte((int) local4 < 0 ? local4 : local4 + 11, (byte) (local56)); + local57 = 11; + local58 = (local4 + local57); + local59 = local58; + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) local59); + callArgs_11[0] = ((long) local55); + instance.getMachine().call(1610, callArgs_11); + local60 = 32; + local61 = (local4 + local60); + instance.global(0).setValue(((long) local61)); + return; + } + + public static long[] call_1660(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1660(arg0, arg1, memory, instance); + return null; + } + + public static int func_1661(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg1); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 23, (byte) (arg2)); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1593, callArgs_0); + local8 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local8); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1590, callArgs_1); + local9 = ((int) callResult_1[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local9); + local10 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local11 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local12 = (local10 - local11); + local13 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local14 = local12; + local15 = local13; + local16 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local14, local15); + local17 = 1; + local18 = (local16 & local17); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local18) != 0) { + break label_2; + } + local19 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local20 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local21 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local22 = (local20 + local21); + local23 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local24 = (local22 - local23); + local25 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local26 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local27 = 0; + long[] callArgs_2 = new long[7]; + callArgs_2[6] = ((long) local27); + callArgs_2[5] = ((long) local27); + callArgs_2[4] = ((long) local26); + callArgs_2[3] = ((long) local25); + callArgs_2[2] = ((long) local24); + callArgs_2[1] = ((long) local19); + callArgs_2[0] = ((long) local6); + instance.getMachine().call(1643, callArgs_2); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local6); + long[] callResult_3 = instance.getMachine().call(1594, callArgs_3); + local28 = ((int) callResult_3[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local28); + local29 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local29); + long[] callResult_4 = instance.getMachine().call(1595, callArgs_4); + local30 = ((int) callResult_4[0]); + local31 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local32 = (local30 + local31); + local33 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local34 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 23) & 0xFF); + local35 = 24; + local36 = (local34 << local35); + local37 = (local36 >> local35); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local37); + callArgs_5[1] = ((long) local33); + callArgs_5[0] = ((long) local32); + long[] callResult_5 = instance.getMachine().call(1644, callArgs_5); + local38 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local39 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local40 = (local39 + local38); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local40); + local41 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local41); + callArgs_6[0] = ((long) local6); + instance.getMachine().call(1608, callArgs_6); + local42 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local43 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local44 = (local42 + local43); + local45 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 7, (byte) (local45)); + local46 = 7; + local47 = (local5 + local46); + local48 = local47; + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local48); + callArgs_7[0] = ((long) local44); + instance.getMachine().call(1610, callArgs_7); + } + local49 = 32; + local50 = (local5 + local49); + instance.global(0).setValue(((long) local50)); + return local6; + } + + public static long[] call_1661(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1661(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1662(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1639, callArgs_0); + local8 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local8); + callArgs_1[1] = ((long) local6); + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1652, callArgs_1); + local9 = ((int) callResult_1[0]); + local10 = 16; + local11 = (local4 + local10); + instance.global(0).setValue(((long) local11)); + return local9; + } + + public static long[] call_1662(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1662(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1663(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1656, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1715, callArgs_1); + local7 = 32; + local8 = (local5 + local7); + instance.global(0).setValue(((long) local8)); + return local6; + } + + public static long[] call_1663(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1663(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1664(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1665, callArgs_0); + local6 = 16; + local7 = (local4 + local6); + instance.global(0).setValue(((long) local7)); + return; + } + + public static long[] call_1664(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1664(arg0, arg1, memory, instance); + return null; + } + + public static void func_1665(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 32; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) arg1); + local5 = 11; + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) local5); + local6 = 9; + local7 = (local4 + local6); + local8 = local7; + local9 = 9; + local10 = (local4 + local9); + local11 = local10; + local12 = 11; + local13 = (local11 + local12); + local14 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + local15 = local4; + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local14); + callArgs_0[2] = ((long) local13); + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local15); + instance.getMachine().call(1666, callArgs_0); + local16 = 9; + local17 = (local4 + local16); + local18 = local17; + local19 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local19); + callArgs_1[1] = ((long) local18); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1667, callArgs_1); + local20 = 32; + local21 = (local4 + local20); + instance.global(0).setValue(((long) local21)); + return; + } + + public static long[] call_1665(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1665(arg0, arg1, memory, instance); + return null; + } + + public static void func_1666(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 32; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 28, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local9 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local9); + callArgs_0[2] = ((long) local8); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1718, callArgs_0); + local10 = 32; + local11 = (local6 + local10); + instance.global(0).setValue(((long) local11)); + return; + } + + public static long[] call_1666(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1666(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_1667(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local7 = 16; + local8 = (local5 + local7); + local9 = local8; + local10 = 8; + local11 = (local5 + local10); + local12 = local11; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local12); + callArgs_0[1] = ((long) local9); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1663, callArgs_0); + local13 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local14 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local14); + callArgs_1[1] = ((long) local13); + callArgs_1[0] = ((long) local6); + instance.getMachine().call(1719, callArgs_1); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + instance.getMachine().call(1655, callArgs_2); + local15 = 32; + local16 = (local5 + local15); + instance.global(0).setValue(((long) local16)); + return local6; + } + + public static long[] call_1667(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1667(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1668(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1669, callArgs_0); + local6 = 16; + local7 = (local4 + local6); + instance.global(0).setValue(((long) local7)); + return; + } + + public static long[] call_1668(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1668(arg0, arg1, memory, instance); + return null; + } + + public static void func_1669(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 32; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 24, (int) arg1); + local5 = 11; + memory.writeI32((int) local4 < 0 ? local4 : local4 + 20, (int) local5); + local6 = 9; + local7 = (local4 + local6); + local8 = local7; + local9 = 9; + local10 = (local4 + local9); + local11 = local10; + local12 = 11; + local13 = (local11 + local12); + local14 = memory.readInt((int) local4 < 0 ? local4 : local4 + 24); + local15 = local4; + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local14); + callArgs_0[2] = ((long) local13); + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local15); + instance.getMachine().call(1670, callArgs_0); + local16 = 9; + local17 = (local4 + local16); + local18 = local17; + local19 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local19); + callArgs_1[1] = ((long) local18); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1667, callArgs_1); + local20 = 32; + local21 = (local4 + local20); + instance.global(0).setValue(((long) local21)); + return; + } + + public static long[] call_1669(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1669(arg0, arg1, memory, instance); + return null; + } + + public static void func_1670(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 32; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 28, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local9 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local9); + callArgs_0[2] = ((long) local8); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1722, callArgs_0); + local10 = 32; + local11 = (local6 + local10); + instance.global(0).setValue(((long) local11)); + return; + } + + public static long[] call_1670(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1670(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_1671(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local10 = local7; + local11 = local9; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local10, local11); + local13 = 1; + local14 = (local12 & local13); + return local14; + } + + public static long[] call_1671(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1671(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1672(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1641, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local7 = 16; + local8 = (local3 + local7); + instance.global(0).setValue(((long) local8)); + return local6; + } + + public static long[] call_1672(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1672(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1673(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1641, callArgs_0); + local5 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1674, callArgs_1); + local6 = ((int) callResult_1[0]); + local7 = 16; + local8 = (local3 + local7); + instance.global(0).setValue(((long) local8)); + return local6; + } + + public static long[] call_1673(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1673(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1674(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1674(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1674(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1675(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1675(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1675(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1676(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1678, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1676(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1676(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1677(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + local0 = -1; + return local0; + } + + public static long[] call_1677(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int result = Wat2WasmMachine.func_1677(memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1678(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1678(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1678(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1679(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1679(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1679(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1680(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1681, callArgs_0); + local6 = ((int) callResult_0[0]); + local7 = 1; + local8 = (local6 & local7); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_2; + } + local9 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local9); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local11 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local11); + callArgs_1[0] = ((long) local10); + long[] callResult_1 = instance.getMachine().call(1682, callArgs_1); + local12 = ((int) callResult_1[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local12); + break label_1; + } + local13 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local13); + long[] callResult_2 = instance.getMachine().call(1683, callArgs_2); + local14 = ((int) callResult_2[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local14); + } + local15 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local16 = 16; + local17 = (local4 + local16); + instance.global(0).setValue(((long) local17)); + return local15; + } + + public static long[] call_1680(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1680(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1681(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = 16; + local6 = local4; + local7 = local5; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, local7); + local9 = 1; + local10 = (local8 & local9); + return local10; + } + + public static long[] call_1681(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1681(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1682(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1778, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1682(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1682(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1683(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1776, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1683(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1683(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1684(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1684(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1684(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1685(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 32; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + local9 = 8; + local10 = (local5 + local9); + local11 = local10; + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local8); + callArgs_0[2] = ((long) local7); + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local11); + instance.getMachine().call(1686, callArgs_0); + local12 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local13 = 32; + local14 = (local5 + local13); + instance.global(0).setValue(((long) local14)); + return local12; + } + + public static long[] call_1685(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1685(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1686(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 16; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local9 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local9); + callArgs_0[2] = ((long) local8); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1687, callArgs_0); + local10 = 16; + local11 = (local6 + local10); + instance.global(0).setValue(((long) local11)); + return; + } + + public static long[] call_1686(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1686(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1687(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 16; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local9 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local9); + callArgs_0[2] = ((long) local8); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1688, callArgs_0); + local10 = 16; + local11 = (local6 + local10); + instance.global(0).setValue(((long) local11)); + return; + } + + public static long[] call_1687(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1687(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1688(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 48; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 44, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 40, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 36, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 44); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + local9 = 24; + local10 = (local6 + local9); + local11 = local10; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local8); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local11); + instance.getMachine().call(1689, callArgs_0); + local12 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local13 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local14 = memory.readInt((int) local6 < 0 ? local6 : local6 + 36); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local14); + long[] callResult_1 = instance.getMachine().call(1690, callArgs_1); + local15 = ((int) callResult_1[0]); + local16 = 16; + local17 = (local6 + local16); + local18 = local17; + local19 = 8; + local20 = (local6 + local19); + local21 = local20; + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) local15); + callArgs_2[3] = ((long) local13); + callArgs_2[2] = ((long) local12); + callArgs_2[1] = ((long) local21); + callArgs_2[0] = ((long) local18); + instance.getMachine().call(1691, callArgs_2); + local22 = memory.readInt((int) local6 < 0 ? local6 : local6 + 44); + local23 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local23); + callArgs_3[0] = ((long) local22); + long[] callResult_3 = instance.getMachine().call(1692, callArgs_3); + local24 = ((int) callResult_3[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local24); + local25 = memory.readInt((int) local6 < 0 ? local6 : local6 + 36); + local26 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local26); + callArgs_4[0] = ((long) local25); + long[] callResult_4 = instance.getMachine().call(1693, callArgs_4); + local27 = ((int) callResult_4[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local27); + local28 = 4; + local29 = (local6 + local28); + local30 = local29; + local31 = local6; + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) local31); + callArgs_5[1] = ((long) local30); + callArgs_5[0] = ((long) arg0); + instance.getMachine().call(1694, callArgs_5); + local32 = 48; + local33 = (local6 + local32); + instance.global(0).setValue(((long) local33)); + return; + } + + public static long[] call_1688(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1688(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1689(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local7); + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1695, callArgs_0); + local8 = 16; + local9 = (local5 + local8); + instance.global(0).setValue(((long) local9)); + return; + } + + public static long[] call_1689(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1689(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1690(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1697, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1690(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1690(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1691(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local5 = ((int) instance.global(0).getValue()); + local6 = 16; + local7 = (local5 - local6); + instance.global(0).setValue(((long) local7)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 8, (int) arg2); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 4, (int) arg3); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 0, (int) arg4); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 8); + local9 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + local10 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local10); + callArgs_0[2] = ((long) local9); + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1696, callArgs_0); + local11 = 16; + local12 = (local7 + local11); + instance.global(0).setValue(((long) local12)); + return; + } + + public static long[] call_1691(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_1691(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static int func_1692(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1699, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1692(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1692(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1693(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1700, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1693(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1693(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1694(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local7); + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1698, callArgs_0); + local8 = 16; + local9 = (local5 + local8); + instance.global(0).setValue(((long) local9)); + return; + } + + public static long[] call_1694(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1694(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_1695(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1701, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local7); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local8); + long[] callResult_1 = instance.getMachine().call(1701, callArgs_1); + local9 = ((int) callResult_1[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local9); + local10 = 4; + local11 = (local5 + local10); + local12 = local11; + local13 = local5; + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local13); + callArgs_2[1] = ((long) local12); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1702, callArgs_2); + local14 = 16; + local15 = (local5 + local14); + instance.global(0).setValue(((long) local15)); + return; + } + + public static long[] call_1695(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1695(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_1696(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 32; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 28, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local9 = (local7 - local8); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) local9); + local10 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local11 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local12 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + local13 = 0; + local14 = (local12 << local13); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local14); + callArgs_0[1] = ((long) local11); + callArgs_0[0] = ((long) local10); + long[] callResult_0 = instance.getMachine().call(1891, callArgs_0); + local15 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local16 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + local17 = (local15 + local16); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) local17); + local18 = 24; + local19 = (local6 + local18); + local20 = local19; + local21 = 12; + local22 = (local6 + local21); + local23 = local22; + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local23); + callArgs_1[1] = ((long) local20); + callArgs_1[0] = ((long) arg0); + instance.getMachine().call(1704, callArgs_1); + local24 = 32; + local25 = (local6 + local24); + instance.global(0).setValue(((long) local25)); + return; + } + + public static long[] call_1696(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1696(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_1697(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1595, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1697(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1697(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1698(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local8); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local10); + return local6; + } + + public static long[] call_1698(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1698(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1699(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1706, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1699(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1699(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1700(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1595, callArgs_0); + local8 = ((int) callResult_0[0]); + local9 = (local6 - local8); + local10 = (local5 + local9); + local11 = 16; + local12 = (local4 + local11); + instance.global(0).setValue(((long) local12)); + return local10; + } + + public static long[] call_1700(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1700(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1701(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1703, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1701(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1701(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1702(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local8); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local10); + return local6; + } + + public static long[] call_1702(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1702(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1703(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1626, callArgs_0); + local5 = ((int) callResult_0[0]); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return local5; + } + + public static long[] call_1703(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1703(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1704(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local7); + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1705, callArgs_0); + local8 = 16; + local9 = (local5 + local8); + instance.global(0).setValue(((long) local9)); + return; + } + + public static long[] call_1704(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1704(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1705(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local8); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local10); + return local6; + } + + public static long[] call_1705(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1705(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1706(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1707, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1706(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1706(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1707(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1626, callArgs_0); + local8 = ((int) callResult_0[0]); + local9 = (local6 - local8); + local10 = (local5 + local9); + local11 = 16; + local12 = (local4 + local11); + instance.global(0).setValue(((long) local12)); + return local10; + } + + public static long[] call_1707(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1707(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1708(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1681, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 1; + local9 = (local7 & local8); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local9) != 0) { + break label_2; + } + local10 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local10); + local11 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local12 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local13 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local13); + callArgs_1[1] = ((long) local12); + callArgs_1[0] = ((long) local11); + instance.getMachine().call(1709, callArgs_1); + break label_1; + } + local14 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local15 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local15); + callArgs_2[0] = ((long) local14); + instance.getMachine().call(1710, callArgs_2); + } + local16 = 16; + local17 = (local5 + local16); + instance.global(0).setValue(((long) local17)); + return; + } + + public static long[] call_1708(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1708(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_1709(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + instance.getMachine().call(1711, callArgs_0); + local8 = 16; + local9 = (local5 + local8); + instance.global(0).setValue(((long) local9)); + return; + } + + public static long[] call_1709(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1709(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_1710(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + instance.getMachine().call(1712, callArgs_0); + local6 = 16; + local7 = (local4 + local6); + instance.global(0).setValue(((long) local7)); + return; + } + + public static long[] call_1710(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1710(arg0, arg1, memory, instance); + return null; + } + + public static void func_1711(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + instance.getMachine().call(1780, callArgs_0); + local7 = 16; + local8 = (local4 + local7); + instance.global(0).setValue(((long) local8)); + return; + } + + public static long[] call_1711(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1711(arg0, arg1, memory, instance); + return null; + } + + public static void func_1712(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_0); + local5 = 16; + local6 = (local3 + local5); + instance.global(0).setValue(((long) local6)); + return; + } + + public static long[] call_1712(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1712(arg0, memory, instance); + return null; + } + + public static int func_1713(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1713(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1713(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1714(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + label_1: { + label_2: while (true) { + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local7 = 0; + local8 = local6; + local9 = local7; + local10 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local8, local9); + local11 = 1; + local12 = (local10 & local11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local12) != 0) { + break label_1; + } + local13 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local14 = ((int) memory.read((int) local13 < 0 ? local13 : local13 + 0) & 0xFF); + local15 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + memory.writeByte((int) local15 < 0 ? local15 : local15 + 0, (byte) (local14)); + local16 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local17 = 1; + local18 = (local16 + local17); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local18); + local19 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local20 = -1; + local21 = (local19 + local20); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local21); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + } + local22 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + return local22; + } + + public static long[] call_1714(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1714(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1715(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1716, callArgs_0); + local5 = 16; + local6 = (local3 + local5); + instance.global(0).setValue(((long) local6)); + return local4; + } + + public static long[] call_1715(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1715(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1716(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1717, callArgs_0); + local5 = 16; + local6 = (local3 + local5); + instance.global(0).setValue(((long) local6)); + return local4; + } + + public static long[] call_1716(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1716(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1717(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1717(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1717(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1718(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 32; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1720, callArgs_0); + local8 = ((int) callResult_0[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local8); + local9 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + local10 = 0; + local11 = local9; + local12 = local10; + local13 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local11, local12); + local14 = 1; + local15 = (local13 & local14); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_1; + } + local16 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local17 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + local18 = local16; + local19 = local17; + local20 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local19, local18); + local21 = 1; + local22 = (local20 & local21); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local22) != 0) { + break label_1; + } + local23 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local24 = 1; + local25 = (local23 + local24); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) local25); + local26 = 45; + memory.writeByte((int) local23 < 0 ? local23 : local23 + 0, (byte) (local26)); + local27 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local27); + long[] callResult_1 = instance.getMachine().call(1721, callArgs_1); + local28 = ((int) callResult_1[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local28); + } + local29 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local30 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + local31 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local31); + callArgs_2[2] = ((long) local30); + callArgs_2[1] = ((long) local29); + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1722, callArgs_2); + local32 = 32; + local33 = (local6 + local32); + instance.global(0).setValue(((long) local33)); + return; + } + + public static long[] call_1718(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1718(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1719(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 48; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 44, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 36, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 44); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 40); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 36); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1738, callArgs_0); + local9 = ((int) callResult_0[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 32, (int) local9); + local10 = memory.readInt((int) local5 < 0 ? local5 : local5 + 32); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1611, callArgs_1); + local11 = ((int) callResult_1[0]); + local12 = local10; + local13 = local11; + local14 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local12, local13); + local15 = 1; + local16 = (local14 & local15); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local16) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local6); + instance.getMachine().call(1612, callArgs_2); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + local17 = memory.readInt((int) local5 < 0 ? local5 : local5 + 32); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local17); + long[] callResult_3 = instance.getMachine().call(1627, callArgs_3); + local18 = ((int) callResult_3[0]); + local19 = 1; + local20 = (local18 & local19); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local20) != 0) { + break label_3; + } + local21 = memory.readInt((int) local5 < 0 ? local5 : local5 + 32); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local21); + callArgs_4[0] = ((long) local6); + instance.getMachine().call(1628, callArgs_4); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local6); + long[] callResult_5 = instance.getMachine().call(1606, callArgs_5); + local22 = ((int) callResult_5[0]); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) local22); + break label_2; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local6); + long[] callResult_6 = instance.getMachine().call(1615, callArgs_6); + local23 = ((int) callResult_6[0]); + local24 = memory.readInt((int) local5 < 0 ? local5 : local5 + 32); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local24); + long[] callResult_7 = instance.getMachine().call(1614, callArgs_7); + local25 = ((int) callResult_7[0]); + local26 = 1; + local27 = (local25 + local26); + local28 = 16; + local29 = (local5 + local28); + local30 = local29; + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) local27); + callArgs_8[1] = ((long) local23); + callArgs_8[0] = ((long) local30); + instance.getMachine().call(1616, callArgs_8); + local31 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) local31); + local32 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local33 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local33); + callArgs_9[0] = ((long) local32); + instance.getMachine().call(1617, callArgs_9); + local34 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) local34); + callArgs_10[0] = ((long) local6); + instance.getMachine().call(1621, callArgs_10); + local35 = memory.readInt((int) local5 < 0 ? local5 : local5 + 20); + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) local35); + callArgs_11[0] = ((long) local6); + instance.getMachine().call(1622, callArgs_11); + local36 = memory.readInt((int) local5 < 0 ? local5 : local5 + 32); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) local36); + callArgs_12[0] = ((long) local6); + instance.getMachine().call(1623, callArgs_12); + } + label_4: { + label_5: while (true) { + local37 = memory.readInt((int) local5 < 0 ? local5 : local5 + 40); + local38 = memory.readInt((int) local5 < 0 ? local5 : local5 + 36); + local39 = local37; + local40 = local38; + local41 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local40, local39); + local42 = 1; + local43 = (local41 & local42); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local43) != 0) { + break label_4; + } + local44 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local45 = memory.readInt((int) local5 < 0 ? local5 : local5 + 40); + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) local45); + callArgs_13[0] = ((long) local44); + instance.getMachine().call(1610, callArgs_13); + local46 = memory.readInt((int) local5 < 0 ? local5 : local5 + 40); + local47 = 1; + local48 = (local46 + local47); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 40, (int) local48); + local49 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local50 = 1; + local51 = (local49 + local50); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 28, (int) local51); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + } + local52 = memory.readInt((int) local5 < 0 ? local5 : local5 + 28); + local53 = 0; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 15, (byte) (local53)); + local54 = 15; + local55 = (local5 + local54); + local56 = local55; + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) local56); + callArgs_14[0] = ((long) local52); + instance.getMachine().call(1610, callArgs_14); + local57 = 48; + local58 = (local5 + local57); + instance.global(0).setValue(((long) local58)); + return; + } + + public static long[] call_1719(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1719(arg0, arg1, arg2, memory, instance); + return null; + } + + public static int func_1720(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1720(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1720(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1721(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = -1; + local6 = (local4 ^ local5); + local7 = 1; + local8 = (local6 + local7); + return local8; + } + + public static long[] call_1721(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1721(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1722(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 32; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local9 = (local7 - local8); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local9); + local10 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local11 = 10; + local12 = local11; + local13 = local10; + local14 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local12, local13); + local15 = 1; + local16 = (local14 & local15); + label_1: { + label_2: { + label_3: { + if (local16 != 0) { + break label_3; + } + local17 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local17); + long[] callResult_0 = instance.getMachine().call(1723, callArgs_0); + local18 = ((int) callResult_0[0]); + local19 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local20 = local18; + local21 = local19; + local22 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local20, local21); + local23 = 1; + local24 = (local22 & local23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local24) != 0) { + break label_2; + } + } + local25 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local26 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local26); + callArgs_1[0] = ((long) local25); + long[] callResult_1 = instance.getMachine().call(1724, callArgs_1); + local27 = ((int) callResult_1[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local27); + local28 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local28); + break label_1; + } + local29 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) local29); + local30 = 61; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local30); + } + local31 = 32; + local32 = (local6 + local31); + instance.global(0).setValue(((long) local32)); + return; + } + + public static long[] call_1722(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1722(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_1723(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = 1; + local6 = (local4 | local5); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1725, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 32; + local9 = (local8 - local7); + local10 = 1233; + local11 = (local9 * local10); + local12 = 12; + local13 = (local11 >> local12); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local13); + local14 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + local15 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local16 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + local17 = 59200; + local18 = 2; + local19 = (local16 << local18); + local20 = (local17 + local19); + local21 = memory.readInt((int) local20 < 0 ? local20 : local20 + 0); + local22 = local15; + local23 = local21; + local24 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local22, local23); + local25 = 1; + local26 = (local24 & local25); + local27 = (local14 - local26); + local28 = 1; + local29 = (local27 + local28); + local30 = 16; + local31 = (local3 + local30); + instance.global(0).setValue(((long) local31)); + return local29; + } + + public static long[] call_1723(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1723(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1724(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1726, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1724(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1724(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1725(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ(local4); + return local5; + } + + public static long[] call_1725(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1725(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1726(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + int local84 = 0; + int local85 = 0; + int local86 = 0; + int local87 = 0; + int local88 = 0; + int local89 = 0; + int local90 = 0; + int local91 = 0; + int local92 = 0; + int local93 = 0; + int local94 = 0; + int local95 = 0; + int local96 = 0; + int local97 = 0; + int local98 = 0; + int local99 = 0; + int local100 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local6 = 1000000; + local7 = local5; + local8 = local6; + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local7, local8); + local10 = 1; + local11 = (local9 & local10); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local11) != 0) { + break label_2; + } + local12 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local13 = 10000; + local14 = local12; + local15 = local13; + local16 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local14, local15); + local17 = 1; + local18 = (local16 & local17); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local18) != 0) { + break label_3; + } + local19 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local20 = 100; + local21 = local19; + local22 = local20; + local23 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local21, local22); + local24 = 1; + local25 = (local23 & local24); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local25) != 0) { + break label_4; + } + local26 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local27 = 10; + local28 = local26; + local29 = local27; + local30 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local28, local29); + local31 = 1; + local32 = (local30 & local31); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local32) != 0) { + break label_5; + } + local33 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local34 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local34); + callArgs_0[0] = ((long) local33); + long[] callResult_0 = instance.getMachine().call(1727, callArgs_0); + local35 = ((int) callResult_0[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local35); + break label_1; + } + local36 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local37 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local37); + callArgs_1[0] = ((long) local36); + long[] callResult_1 = instance.getMachine().call(1728, callArgs_1); + local38 = ((int) callResult_1[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local38); + break label_1; + } + local39 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local40 = 1000; + local41 = local39; + local42 = local40; + local43 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local41, local42); + local44 = 1; + local45 = (local43 & local44); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local45) != 0) { + break label_6; + } + local46 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local47 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) local47); + callArgs_2[0] = ((long) local46); + long[] callResult_2 = instance.getMachine().call(1729, callArgs_2); + local48 = ((int) callResult_2[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local48); + break label_1; + } + local49 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local50 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local50); + callArgs_3[0] = ((long) local49); + long[] callResult_3 = instance.getMachine().call(1730, callArgs_3); + local51 = ((int) callResult_3[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local51); + break label_1; + } + local52 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local53 = 100000; + local54 = local52; + local55 = local53; + local56 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local54, local55); + local57 = 1; + local58 = (local56 & local57); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local58) != 0) { + break label_7; + } + local59 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local60 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local60); + callArgs_4[0] = ((long) local59); + long[] callResult_4 = instance.getMachine().call(1731, callArgs_4); + local61 = ((int) callResult_4[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local61); + break label_1; + } + local62 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local63 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local63); + callArgs_5[0] = ((long) local62); + long[] callResult_5 = instance.getMachine().call(1732, callArgs_5); + local64 = ((int) callResult_5[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local64); + break label_1; + } + local65 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local66 = 100000000; + local67 = local65; + local68 = local66; + local69 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local67, local68); + local70 = 1; + local71 = (local69 & local70); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local71) != 0) { + break label_8; + } + local72 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local73 = 10000000; + local74 = local72; + local75 = local73; + local76 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local74, local75); + local77 = 1; + local78 = (local76 & local77); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local78) != 0) { + break label_9; + } + local79 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local80 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) local80); + callArgs_6[0] = ((long) local79); + long[] callResult_6 = instance.getMachine().call(1733, callArgs_6); + local81 = ((int) callResult_6[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local81); + break label_1; + } + local82 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local83 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) local83); + callArgs_7[0] = ((long) local82); + long[] callResult_7 = instance.getMachine().call(1734, callArgs_7); + local84 = ((int) callResult_7[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local84); + break label_1; + } + local85 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local86 = 1000000000; + local87 = local85; + local88 = local86; + local89 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local87, local88); + local90 = 1; + local91 = (local89 & local90); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local91) != 0) { + break label_10; + } + local92 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local93 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) local93); + callArgs_8[0] = ((long) local92); + long[] callResult_8 = instance.getMachine().call(1735, callArgs_8); + local94 = ((int) callResult_8[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local94); + break label_1; + } + local95 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local96 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) local96); + callArgs_9[0] = ((long) local95); + long[] callResult_9 = instance.getMachine().call(1736, callArgs_9); + local97 = ((int) callResult_9[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local97); + } + local98 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local99 = 16; + local100 = (local4 + local99); + instance.global(0).setValue(((long) local100)); + return local98; + } + + public static long[] call_1726(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1726(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1727(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local6 = 24; + local7 = (local5 << local6); + local8 = (local7 >> local6); + local9 = 48; + local10 = (local8 + local9); + local11 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + memory.writeByte((int) local11 < 0 ? local11 : local11 + 0, (byte) (local10)); + local12 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local13 = 1; + local14 = (local12 + local13); + return local14; + } + + public static long[] call_1727(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1727(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1728(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local6 = 1; + local7 = (local5 << local6); + local8 = 59248; + local9 = (local8 + local7); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local11 = 2; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local10); + callArgs_0[1] = ((long) local11); + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1737, callArgs_0); + local12 = ((int) callResult_0[0]); + local13 = 16; + local14 = (local4 + local13); + instance.global(0).setValue(((long) local14)); + return local12; + } + + public static long[] call_1728(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1728(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1729(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = 100; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local6, local7); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1727, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local11 = 100; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local10, local11); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local12); + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1728, callArgs_1); + local13 = ((int) callResult_1[0]); + local14 = 16; + local15 = (local4 + local14); + instance.global(0).setValue(((long) local15)); + return local13; + } + + public static long[] call_1729(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1729(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1730(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = 100; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local6, local7); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1728, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local11 = 100; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local10, local11); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local12); + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1728, callArgs_1); + local13 = ((int) callResult_1[0]); + local14 = 16; + local15 = (local4 + local14); + instance.global(0).setValue(((long) local15)); + return local13; + } + + public static long[] call_1730(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1730(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1731(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = 10000; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local6, local7); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1727, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local11 = 10000; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local10, local11); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local12); + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1730, callArgs_1); + local13 = ((int) callResult_1[0]); + local14 = 16; + local15 = (local4 + local14); + instance.global(0).setValue(((long) local15)); + return local13; + } + + public static long[] call_1731(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1731(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1732(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = 10000; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local6, local7); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1728, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local11 = 10000; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local10, local11); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local12); + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1730, callArgs_1); + local13 = ((int) callResult_1[0]); + local14 = 16; + local15 = (local4 + local14); + instance.global(0).setValue(((long) local15)); + return local13; + } + + public static long[] call_1732(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1732(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1733(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = 1000000; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local6, local7); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1727, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local11 = 1000000; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local10, local11); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local12); + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1732, callArgs_1); + local13 = ((int) callResult_1[0]); + local14 = 16; + local15 = (local4 + local14); + instance.global(0).setValue(((long) local15)); + return local13; + } + + public static long[] call_1733(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1733(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1734(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = 1000000; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local6, local7); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1728, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local11 = 1000000; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local10, local11); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local12); + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1732, callArgs_1); + local13 = ((int) callResult_1[0]); + local14 = 16; + local15 = (local4 + local14); + instance.global(0).setValue(((long) local15)); + return local13; + } + + public static long[] call_1734(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1734(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1735(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = 100000000; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local6, local7); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1727, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local11 = 100000000; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local10, local11); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local12); + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1734, callArgs_1); + local13 = ((int) callResult_1[0]); + local14 = 16; + local15 = (local4 + local14); + instance.global(0).setValue(((long) local15)); + return local13; + } + + public static long[] call_1735(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1735(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1736(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = 100000000; + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local6, local7); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local8); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1728, callArgs_0); + local9 = ((int) callResult_0[0]); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local11 = 100000000; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(local10, local11); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local12); + callArgs_1[0] = ((long) local9); + long[] callResult_1 = instance.getMachine().call(1734, callArgs_1); + local13 = ((int) callResult_1[0]); + local14 = 16; + local15 = (local4 + local14); + instance.global(0).setValue(((long) local15)); + return local13; + } + + public static long[] call_1736(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1736(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1737(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local6); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local8 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local9 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + local10 = (local8 + local9); + local11 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local11); + callArgs_0[1] = ((long) local10); + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1685, callArgs_0); + local12 = ((int) callResult_0[0]); + local13 = 16; + local14 = (local5 + local13); + instance.global(0).setValue(((long) local14)); + return local12; + } + + public static long[] call_1737(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1737(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1738(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local6); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1739, callArgs_0); + local7 = ((int) callResult_0[0]); + local8 = 16; + local9 = (local4 + local8); + instance.global(0).setValue(((long) local9)); + return local7; + } + + public static long[] call_1738(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1738(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1739(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local7 = (local5 - local6); + return local7; + } + + public static long[] call_1739(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1739(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1740(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local4; + } + + public static long[] call_1740(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1740(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1741(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1740, callArgs_0); + local5 = 16; + local6 = (local3 + local5); + instance.global(0).setValue(((long) local6)); + return local4; + } + + public static long[] call_1741(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1741(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1742(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + return; + } + + public static long[] call_1742(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1742(arg0, memory, instance); + return null; + } + + public static void func_1743(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + return; + } + + public static long[] call_1743(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1743(arg0, memory, instance); + return null; + } + + public static int func_1744(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1741, callArgs_0); + local5 = 16; + local6 = (local3 + local5); + instance.global(0).setValue(((long) local6)); + return local4; + } + + public static long[] call_1744(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1744(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1745(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = 894; + int ciTableIdx_0 = (int) (local5); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_1); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return; + } + + public static long[] call_1745(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1745(arg0, memory, instance); + return null; + } + + public static int func_1746(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1741, callArgs_0); + local5 = 16; + local6 = (local3 + local5); + instance.global(0).setValue(((long) local6)); + return local4; + } + + public static long[] call_1746(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1746(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1747(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = 895; + int ciTableIdx_0 = (int) (local5); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_1); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return; + } + + public static long[] call_1747(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1747(arg0, memory, instance); + return null; + } + + public static int func_1748(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1746, callArgs_0); + local5 = 16; + local6 = (local3 + local5); + instance.global(0).setValue(((long) local6)); + return local4; + } + + public static long[] call_1748(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1748(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1749(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = 896; + int ciTableIdx_0 = (int) (local5); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_1); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return; + } + + public static long[] call_1749(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1749(arg0, memory, instance); + return null; + } + + public static int func_1750(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1746, callArgs_0); + local5 = 16; + local6 = (local3 + local5); + instance.global(0).setValue(((long) local6)); + return local4; + } + + public static long[] call_1750(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1750(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1751(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + local5 = 897; + int ciTableIdx_0 = (int) (local5); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local4); + instance.getMachine().call(1777, callArgs_1); + local6 = 16; + local7 = (local3 + local6); + instance.global(0).setValue(((long) local7)); + return; + } + + public static long[] call_1751(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1751(arg0, memory, instance); + return null; + } + + public static int func_1752(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 12); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local8 = 0; + local9 = 1; + local10 = (local8 & local9); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local10); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local11 = ((int) callResult_0[0]); + local12 = 1; + local13 = (local11 & local12); + local14 = 16; + local15 = (local5 + local14); + instance.global(0).setValue(((long) local15)); + return local13; + } + + public static long[] call_1752(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1752(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1753(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 16; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) arg1); + local6 = arg2; + memory.writeByte((int) local5 < 0 ? local5 : local5 + 3, (byte) (local6)); + local7 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 3) & 0xFF); + local8 = 1; + local9 = (local7 & local8); + label_1: { + label_2: { + if (local9 != 0) { + break label_2; + } + local10 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local11 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local11); + callArgs_0[0] = ((long) local10); + long[] callResult_0 = instance.getMachine().call(1754, callArgs_0); + local12 = ((int) callResult_0[0]); + local13 = 1; + local14 = (local12 & local13); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 15, (byte) (local14)); + break label_1; + } + local15 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + local16 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local17 = local15; + local18 = local16; + local19 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local18, local17); + local20 = 1; + local21 = 1; + local22 = (local19 & local21); + local23 = local20; + label_3: { + if (local22 != 0) { + break label_3; + } + local24 = memory.readInt((int) local5 < 0 ? local5 : local5 + 8); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local24); + long[] callResult_1 = instance.getMachine().call(1755, callArgs_1); + local25 = ((int) callResult_1[0]); + local26 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local26); + long[] callResult_2 = instance.getMachine().call(1755, callArgs_2); + local27 = ((int) callResult_2[0]); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local27); + callArgs_3[0] = ((long) local25); + long[] callResult_3 = instance.getMachine().call(1895, callArgs_3); + local28 = ((int) callResult_3[0]); + local29 = 0; + local30 = local28; + local31 = local29; + local32 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local31, local30); + local23 = local32; + } + local33 = local23; + local34 = 1; + local35 = (local33 & local34); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 15, (byte) (local35)); + } + local36 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 15) & 0xFF); + local37 = 1; + local38 = (local36 & local37); + local39 = 16; + local40 = (local5 + local39); + instance.global(0).setValue(((long) local40)); + return local38; + } + + public static long[] call_1753(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1753(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1754(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 4); + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local6); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local8); + local9 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local11 = local9; + local12 = local10; + local13 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local12, local11); + local14 = 1; + local15 = (local13 & local14); + return local15; + } + + public static long[] call_1754(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1754(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1755(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local5); + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + return local6; + } + + public static long[] call_1755(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1755(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1756(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + long local43 = 0L; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + local3 = ((int) instance.global(0).getValue()); + local4 = 80; + local5 = (local3 - local4); + instance.global(0).setValue(((long) local5)); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 72, (int) arg0); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 68, (int) arg1); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 64, (int) arg2); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 72); + local7 = memory.readInt((int) local5 < 0 ? local5 : local5 + 68); + local8 = 0; + local9 = 1; + local10 = (local8 & local9); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local10); + callArgs_0[1] = ((long) local7); + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local11 = ((int) callResult_0[0]); + local12 = 1; + local13 = (local11 & local12); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local13) != 0) { + break label_2; + } + local14 = 1; + local15 = 1; + local16 = (local14 & local15); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 79, (byte) (local16)); + break label_1; + } + local17 = memory.readInt((int) local5 < 0 ? local5 : local5 + 68); + local18 = 0; + local19 = local17; + local20 = local18; + local21 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local20, local19); + local22 = 1; + local23 = (local21 & local22); + label_3: { + label_4: { + if (local23 != 0) { + break label_4; + } + local24 = 59508; + local25 = 59556; + local26 = 0; + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local26); + callArgs_1[2] = ((long) local25); + callArgs_1[1] = ((long) local24); + callArgs_1[0] = ((long) local17); + long[] callResult_1 = instance.getMachine().call(1757, callArgs_1); + local27 = ((int) callResult_1[0]); + local28 = local27; + break label_3; + } + local29 = 0; + local28 = local29; + } + local30 = local28; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 60, (int) local30); + local31 = memory.readInt((int) local5 < 0 ? local5 : local5 + 60); + local32 = 0; + local33 = local31; + local34 = local32; + local35 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local34, local33); + local36 = 1; + local37 = (local35 & local36); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local37) != 0) { + break label_5; + } + local38 = 0; + local39 = 1; + local40 = (local38 & local39); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 79, (byte) (local40)); + break label_1; + } + local41 = 48; + local42 = (local5 + local41); + local43 = 0L; + memory.writeLong((int) local42 < 0 ? local42 : local42 + 0, (long) local43); + local44 = 40; + local45 = (local5 + local44); + memory.writeLong((int) local45 < 0 ? local45 : local45 + 0, (long) local43); + local46 = 32; + local47 = (local5 + local46); + memory.writeLong((int) local47 < 0 ? local47 : local47 + 0, (long) local43); + local48 = 24; + local49 = (local5 + local48); + memory.writeLong((int) local49 < 0 ? local49 : local49 + 0, (long) local43); + local50 = 16; + local51 = (local5 + local50); + memory.writeLong((int) local51 < 0 ? local51 : local51 + 0, (long) local43); + local52 = 8; + local53 = (local5 + local52); + memory.writeLong((int) local53 < 0 ? local53 : local53 + 0, (long) local43); + memory.writeLong((int) local5 < 0 ? local5 : local5 + 0, (long) local43); + local54 = memory.readInt((int) local5 < 0 ? local5 : local5 + 60); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local54); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local6); + local55 = -1; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local55); + local56 = 1; + memory.writeI32((int) local5 < 0 ? local5 : local5 + 48, (int) local56); + local57 = memory.readInt((int) local5 < 0 ? local5 : local5 + 60); + local58 = memory.readInt((int) local5 < 0 ? local5 : local5 + 64); + local59 = memory.readInt((int) local58 < 0 ? local58 : local58 + 0); + local60 = memory.readInt((int) local57 < 0 ? local57 : local57 + 0); + local61 = memory.readInt((int) local60 < 0 ? local60 : local60 + 28); + local62 = local5; + local63 = 1; + int ciTableIdx_2 = (int) (local61); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(16))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local63); + callArgs_2[2] = ((long) local59); + callArgs_2[1] = ((long) local62); + callArgs_2[0] = ((long) local57); + ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + local64 = memory.readInt((int) local5 < 0 ? local5 : local5 + 24); + local65 = 1; + local66 = local64; + local67 = local65; + local68 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local67, local66); + local69 = 1; + local70 = (local68 & local69); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local70) != 0) { + break label_6; + } + local71 = memory.readInt((int) local5 < 0 ? local5 : local5 + 16); + local72 = memory.readInt((int) local5 < 0 ? local5 : local5 + 64); + memory.writeI32((int) local72 < 0 ? local72 : local72 + 0, (int) local71); + local73 = 1; + local74 = 1; + local75 = (local73 & local74); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 79, (byte) (local75)); + break label_1; + } + local76 = 0; + local77 = 1; + local78 = (local76 & local77); + memory.writeByte((int) local5 < 0 ? local5 : local5 + 79, (byte) (local78)); + } + local79 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 79) & 0xFF); + local80 = 1; + local81 = (local79 & local80); + local82 = 80; + local83 = (local5 + local82); + instance.global(0).setValue(((long) local83)); + return local81; + } + + public static long[] call_1756(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1756(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1757(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + int local84 = 0; + int local85 = 0; + int local86 = 0; + int local87 = 0; + int local88 = 0; + int local89 = 0; + int local90 = 0; + int local91 = 0; + int local92 = 0; + int local93 = 0; + int local94 = 0; + int local95 = 0; + int local96 = 0; + int local97 = 0; + int local98 = 0; + int local99 = 0; + int local100 = 0; + int local101 = 0; + int local102 = 0; + int local103 = 0; + int local104 = 0; + int local105 = 0; + int local106 = 0; + int local107 = 0; + int local108 = 0; + int local109 = 0; + int local110 = 0; + int local111 = 0; + int local112 = 0; + int local113 = 0; + int local114 = 0; + int local115 = 0; + int local116 = 0; + int local117 = 0; + int local118 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 96; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 92, (int) arg0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 88, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 84, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 80, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 92); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 76, (int) local8); + local9 = memory.readInt((int) local6 < 0 ? local6 : local6 + 76); + local10 = -8; + local11 = (local9 + local10); + local12 = memory.readInt((int) local11 < 0 ? local11 : local11 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 72, (int) local12); + local13 = memory.readInt((int) local6 < 0 ? local6 : local6 + 92); + local14 = memory.readInt((int) local6 < 0 ? local6 : local6 + 72); + local15 = (local13 + local14); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 68, (int) local15); + local16 = memory.readInt((int) local6 < 0 ? local6 : local6 + 76); + local17 = -4; + local18 = (local16 + local17); + local19 = memory.readInt((int) local18 < 0 ? local18 : local18 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 64, (int) local19); + local20 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 60, (int) local20); + local21 = memory.readInt((int) local6 < 0 ? local6 : local6 + 84); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) local21); + local22 = memory.readInt((int) local6 < 0 ? local6 : local6 + 92); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) local22); + local23 = memory.readInt((int) local6 < 0 ? local6 : local6 + 88); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local23); + local24 = memory.readInt((int) local6 < 0 ? local6 : local6 + 80); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) local24); + local25 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) local25); + local26 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) local26); + local27 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) local27); + local28 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 28, (int) local28); + local29 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 32, (int) local29); + local30 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 36, (int) local30); + local31 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 40, (int) local31); + local32 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 44, (int) local32); + local33 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 48, (int) local33); + local34 = 0; + memory.writeByte((int) local6 < 0 ? local6 : local6 + 52, (byte) (local34)); + local35 = 0; + memory.writeByte((int) local6 < 0 ? local6 : local6 + 53, (byte) (local35)); + local36 = 0; + memory.writeByte((int) local6 < 0 ? local6 : local6 + 54, (byte) (local36)); + local37 = memory.readInt((int) local6 < 0 ? local6 : local6 + 64); + local38 = memory.readInt((int) local6 < 0 ? local6 : local6 + 84); + local39 = 0; + local40 = 1; + local41 = (local39 & local40); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local41); + callArgs_0[1] = ((long) local38); + callArgs_0[0] = ((long) local37); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local42 = ((int) callResult_0[0]); + local43 = 1; + local44 = (local42 & local43); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local44) != 0) { + break label_2; + } + local45 = 1; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 48, (int) local45); + local46 = memory.readInt((int) local6 < 0 ? local6 : local6 + 64); + local47 = memory.readInt((int) local6 < 0 ? local6 : local6 + 68); + local48 = memory.readInt((int) local6 < 0 ? local6 : local6 + 68); + local49 = memory.readInt((int) local46 < 0 ? local46 : local46 + 0); + local50 = memory.readInt((int) local49 < 0 ? local49 : local49 + 20); + local51 = local6; + local52 = 1; + local53 = 0; + local54 = 1; + local55 = (local53 & local54); + int ciTableIdx_1 = (int) (local50); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(17))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[6]; + callArgs_1[5] = ((long) local55); + callArgs_1[4] = ((long) local52); + callArgs_1[3] = ((long) local48); + callArgs_1[2] = ((long) local47); + callArgs_1[1] = ((long) local51); + callArgs_1[0] = ((long) local46); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local56 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local57 = 1; + local58 = local56; + local59 = local57; + local60 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local59, local58); + local61 = 1; + local62 = (local60 & local61); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local62) != 0) { + break label_3; + } + local63 = memory.readInt((int) local6 < 0 ? local6 : local6 + 68); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 60, (int) local63); + } + break label_1; + } + local64 = memory.readInt((int) local6 < 0 ? local6 : local6 + 64); + local65 = memory.readInt((int) local6 < 0 ? local6 : local6 + 68); + local66 = memory.readInt((int) local64 < 0 ? local64 : local64 + 0); + local67 = memory.readInt((int) local66 < 0 ? local66 : local66 + 24); + local68 = 0; + local69 = 1; + int ciTableIdx_2 = (int) (local67); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(18))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) local68); + callArgs_2[3] = ((long) local69); + callArgs_2[2] = ((long) local65); + callArgs_2[1] = ((long) local6); + callArgs_2[0] = ((long) local64); + ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + local70 = memory.readInt((int) local6 < 0 ? local6 : local6 + 36); + com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local70, local69); + label_4: { + label_5: { + label_6: { + switch(local70) { + case 0: + { + break label_6; + } + case 1: + { + break label_5; + } + default: + { + break label_4; + } + } + } + local71 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + local72 = 1; + local73 = local71; + local74 = local72; + local75 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local74, local73); + local76 = 1; + local77 = (local75 & local76); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local77) != 0) { + break label_7; + } + local78 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local79 = 1; + local80 = local78; + local81 = local79; + local82 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local81, local80); + local83 = 1; + local84 = (local82 & local83); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local84) != 0) { + break label_7; + } + local85 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + local86 = 1; + local87 = local85; + local88 = local86; + local89 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local88, local87); + local90 = 1; + local91 = (local89 & local90); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local91) != 0) { + break label_7; + } + local92 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 60, (int) local92); + } + break label_4; + } + local93 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local94 = 1; + local95 = local93; + local96 = local94; + local97 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local96, local95); + local98 = 1; + local99 = (local97 & local98); + label_8: { + label_9: { + if (local99 != 0) { + break label_9; + } + local100 = memory.readInt((int) local6 < 0 ? local6 : local6 + 40); + if (local100 != 0) { + break label_8; + } + local101 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local102 = 1; + local103 = local101; + local104 = local102; + local105 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local104, local103); + local106 = 1; + local107 = (local105 & local106); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local107) != 0) { + break label_8; + } + local108 = memory.readInt((int) local6 < 0 ? local6 : local6 + 32); + local109 = 1; + local110 = local108; + local111 = local109; + local112 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local111, local110); + local113 = 1; + local114 = (local112 & local113); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local114) != 0) { + break label_8; + } + } + local115 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 60, (int) local115); + } + } + } + local116 = memory.readInt((int) local6 < 0 ? local6 : local6 + 60); + local117 = 96; + local118 = (local6 + local117); + instance.global(0).setValue(((long) local118)); + return local116; + } + + public static long[] call_1757(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1757(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1758(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 16; + local6 = (local4 - local5); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) arg0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local9 = 0; + local10 = local8; + local11 = local9; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local11, local10); + local13 = 1; + local14 = (local12 & local13); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local14) != 0) { + break label_2; + } + local15 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + local16 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + memory.writeI32((int) local16 < 0 ? local16 : local16 + 16, (int) local15); + local17 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local18 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + memory.writeI32((int) local18 < 0 ? local18 : local18 + 24, (int) local17); + local19 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local20 = 1; + memory.writeI32((int) local19 < 0 ? local19 : local19 + 36, (int) local20); + break label_1; + } + local21 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local22 = memory.readInt((int) local21 < 0 ? local21 : local21 + 16); + local23 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + local24 = local22; + local25 = local23; + local26 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local25, local24); + local27 = 1; + local28 = (local26 & local27); + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local28) != 0) { + break label_4; + } + local29 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local30 = memory.readInt((int) local29 < 0 ? local29 : local29 + 24); + local31 = 2; + local32 = local30; + local33 = local31; + local34 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local33, local32); + local35 = 1; + local36 = (local34 & local35); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local36) != 0) { + break label_5; + } + local37 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local38 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + memory.writeI32((int) local38 < 0 ? local38 : local38 + 24, (int) local37); + } + break label_3; + } + local39 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local40 = memory.readInt((int) local39 < 0 ? local39 : local39 + 36); + local41 = 1; + local42 = (local40 + local41); + memory.writeI32((int) local39 < 0 ? local39 : local39 + 36, (int) local42); + local43 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local44 = 2; + memory.writeI32((int) local43 < 0 ? local43 : local43 + 24, (int) local44); + local45 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local46 = 1; + memory.writeByte((int) local45 < 0 ? local45 : local45 + 54, (byte) (local46)); + } + } + return; + } + + public static long[] call_1758(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1758(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1759(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 16; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) arg0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 8); + local10 = 0; + local11 = 1; + local12 = (local10 & local11); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local12); + callArgs_0[1] = ((long) local9); + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local13 = ((int) callResult_0[0]); + local14 = 1; + local15 = (local13 & local14); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_1; + } + local16 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local17 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + local18 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local18); + callArgs_1[2] = ((long) local17); + callArgs_1[1] = ((long) local16); + callArgs_1[0] = ((long) local7); + instance.getMachine().call(1758, callArgs_1); + } + local19 = 16; + local20 = (local6 + local19); + instance.global(0).setValue(((long) local20)); + return; + } + + public static long[] call_1759(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1759(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1760(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 16; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) arg0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 8); + local10 = 0; + local11 = 1; + local12 = (local10 & local11); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local12); + callArgs_0[1] = ((long) local9); + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local13 = ((int) callResult_0[0]); + local14 = 1; + local15 = (local13 & local14); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_2; + } + local16 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local17 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + local18 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local18); + callArgs_1[2] = ((long) local17); + callArgs_1[1] = ((long) local16); + callArgs_1[0] = ((long) local7); + instance.getMachine().call(1758, callArgs_1); + break label_1; + } + local19 = memory.readInt((int) local7 < 0 ? local7 : local7 + 8); + local20 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local21 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + local22 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local23 = memory.readInt((int) local19 < 0 ? local19 : local19 + 0); + local24 = memory.readInt((int) local23 < 0 ? local23 : local23 + 28); + int ciTableIdx_2 = (int) (local24); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(16))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local22); + callArgs_2[2] = ((long) local21); + callArgs_2[1] = ((long) local20); + callArgs_2[0] = ((long) local19); + ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + } + local25 = 16; + local26 = (local6 + local25); + instance.global(0).setValue(((long) local26)); + return; + } + + public static long[] call_1760(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1760(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1761(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 32; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 28, (int) arg0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local8 = 0; + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) local8); + local9 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local10 = 0; + local11 = local9; + local12 = local10; + local13 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local12, local11); + local14 = 1; + local15 = (local13 & local14); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_1; + } + local16 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + local17 = 8; + local18 = (local16 >> local17); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) local18); + local19 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + local20 = 1; + local21 = (local19 & local20); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local21) != 0) { + break label_2; + } + local22 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local23 = memory.readInt((int) local22 < 0 ? local22 : local22 + 0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local23); + local24 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local25 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local25); + callArgs_0[0] = ((long) local24); + long[] callResult_0 = instance.getMachine().call(1762, callArgs_0); + local26 = ((int) callResult_0[0]); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) local26); + } + } + local27 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + local28 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local29 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local30 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + local31 = (local29 + local30); + local32 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + local33 = 2; + local34 = (local32 & local33); + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local34) != 0) { + break label_4; + } + local35 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + local36 = local35; + break label_3; + } + local37 = 2; + local36 = local37; + } + local38 = local36; + local39 = memory.readInt((int) local27 < 0 ? local27 : local27 + 0); + local40 = memory.readInt((int) local39 < 0 ? local39 : local39 + 28); + int ciTableIdx_1 = (int) (local40); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(16))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local38); + callArgs_1[2] = ((long) local31); + callArgs_1[1] = ((long) local28); + callArgs_1[0] = ((long) local27); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local41 = 32; + local42 = (local6 + local41); + instance.global(0).setValue(((long) local42)); + return; + } + + public static long[] call_1761(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1761(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static int func_1762(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local7 = (local5 + local6); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 0); + return local8; + } + + public static long[] call_1762(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1762(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1763(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 32; + local6 = (local4 - local5); + instance.global(0).setValue(((long) local6)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 28, (int) arg0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 20, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 28); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 8); + local10 = 0; + local11 = 1; + local12 = (local10 & local11); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local12); + callArgs_0[1] = ((long) local9); + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local13 = ((int) callResult_0[0]); + local14 = 1; + local15 = (local13 & local14); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_2; + } + local16 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local17 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local18 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local18); + callArgs_1[2] = ((long) local17); + callArgs_1[1] = ((long) local16); + callArgs_1[0] = ((long) local7); + instance.getMachine().call(1758, callArgs_1); + break label_1; + } + local19 = 16; + local20 = (local7 + local19); + local21 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local22 = 3; + local23 = (local21 << local22); + local24 = (local20 + local23); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) local24); + local25 = 16; + local26 = (local7 + local25); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local26); + local27 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local28 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local29 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local30 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) local30); + callArgs_2[2] = ((long) local29); + callArgs_2[1] = ((long) local28); + callArgs_2[0] = ((long) local27); + instance.getMachine().call(1761, callArgs_2); + local31 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local32 = 8; + local33 = (local31 + local32); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local33); + local34 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + local35 = local33; + local36 = local34; + local37 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local35, local36); + local38 = 1; + local39 = (local37 & local38); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local39) != 0) { + break label_3; + } + label_4: { + label_5: while (true) { + local40 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local41 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local42 = memory.readInt((int) local6 < 0 ? local6 : local6 + 20); + local43 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) local43); + callArgs_3[2] = ((long) local42); + callArgs_3[1] = ((long) local41); + callArgs_3[0] = ((long) local40); + instance.getMachine().call(1761, callArgs_3); + local44 = memory.readInt((int) local6 < 0 ? local6 : local6 + 24); + local45 = ((int) memory.read((int) local44 < 0 ? local44 : local44 + 54) & 0xFF); + local46 = 1; + local47 = (local45 & local46); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local47) != 0) { + break label_6; + } + break label_4; + } + local48 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local49 = 8; + local50 = (local48 + local49); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local50); + local51 = memory.readInt((int) local6 < 0 ? local6 : local6 + 12); + local52 = local50; + local53 = local51; + local54 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local52, local53); + local55 = 1; + local56 = (local54 & local55); + if (local56 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + } + } + local57 = 32; + local58 = (local6 + local57); + instance.global(0).setValue(((long) local58)); + return; + } + + public static long[] call_1763(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1763(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1764(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + int local84 = 0; + int local85 = 0; + int local86 = 0; + int local87 = 0; + int local88 = 0; + int local89 = 0; + int local90 = 0; + int local91 = 0; + int local92 = 0; + int local93 = 0; + local5 = ((int) instance.global(0).getValue()); + local6 = 32; + local7 = (local5 - local6); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) arg0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 24, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 20, (int) arg2); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 16, (int) arg3); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) arg4); + local8 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local9 = 1; + memory.writeByte((int) local8 < 0 ? local8 : local8 + 53, (byte) (local9)); + local10 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local11 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local12 = memory.readInt((int) local11 < 0 ? local11 : local11 + 4); + local13 = local10; + local14 = local12; + local15 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local14, local13); + local16 = 1; + local17 = (local15 & local16); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local17) != 0) { + break label_1; + } + local18 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local19 = 1; + memory.writeByte((int) local18 < 0 ? local18 : local18 + 52, (byte) (local19)); + local20 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local21 = memory.readInt((int) local20 < 0 ? local20 : local20 + 16); + local22 = 0; + local23 = local21; + local24 = local22; + local25 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local24, local23); + local26 = 1; + local27 = (local25 & local26); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local27) != 0) { + break label_3; + } + local28 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local29 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + memory.writeI32((int) local29 < 0 ? local29 : local29 + 16, (int) local28); + local30 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local31 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + memory.writeI32((int) local31 < 0 ? local31 : local31 + 24, (int) local30); + local32 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local33 = 1; + memory.writeI32((int) local32 < 0 ? local32 : local32 + 36, (int) local33); + local34 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local35 = memory.readInt((int) local34 < 0 ? local34 : local34 + 48); + local36 = 1; + local37 = local35; + local38 = local36; + local39 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local38, local37); + local40 = 1; + local41 = (local39 & local40); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local41) != 0) { + break label_4; + } + local42 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local43 = memory.readInt((int) local42 < 0 ? local42 : local42 + 24); + local44 = 1; + local45 = local43; + local46 = local44; + local47 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local46, local45); + local48 = 1; + local49 = (local47 & local48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local49) != 0) { + break label_4; + } + local50 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local51 = 1; + memory.writeByte((int) local50 < 0 ? local50 : local50 + 54, (byte) (local51)); + } + break label_2; + } + local52 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local53 = memory.readInt((int) local52 < 0 ? local52 : local52 + 16); + local54 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local55 = local53; + local56 = local54; + local57 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local56, local55); + local58 = 1; + local59 = (local57 & local58); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local59) != 0) { + break label_6; + } + local60 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local61 = memory.readInt((int) local60 < 0 ? local60 : local60 + 24); + local62 = 2; + local63 = local61; + local64 = local62; + local65 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local64, local63); + local66 = 1; + local67 = (local65 & local66); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local67) != 0) { + break label_7; + } + local68 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local69 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + memory.writeI32((int) local69 < 0 ? local69 : local69 + 24, (int) local68); + } + local70 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local71 = memory.readInt((int) local70 < 0 ? local70 : local70 + 48); + local72 = 1; + local73 = local71; + local74 = local72; + local75 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local74, local73); + local76 = 1; + local77 = (local75 & local76); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local77) != 0) { + break label_8; + } + local78 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local79 = memory.readInt((int) local78 < 0 ? local78 : local78 + 24); + local80 = 1; + local81 = local79; + local82 = local80; + local83 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local82, local81); + local84 = 1; + local85 = (local83 & local84); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local85) != 0) { + break label_8; + } + local86 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local87 = 1; + memory.writeByte((int) local86 < 0 ? local86 : local86 + 54, (byte) (local87)); + } + break label_5; + } + local88 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local89 = memory.readInt((int) local88 < 0 ? local88 : local88 + 36); + local90 = 1; + local91 = (local89 + local90); + memory.writeI32((int) local88 < 0 ? local88 : local88 + 36, (int) local91); + local92 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local93 = 1; + memory.writeByte((int) local92 < 0 ? local92 : local92 + 54, (byte) (local93)); + } + } + } + return; + } + + public static long[] call_1764(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_1764(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static void func_1765(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + local4 = ((int) instance.global(0).getValue()); + local5 = 16; + local6 = (local4 - local5); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 12, (int) arg0); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) arg1); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) arg2); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) arg3); + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + local8 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 4); + local10 = local7; + local11 = local9; + local12 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local11, local10); + local13 = 1; + local14 = (local12 & local13); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local14) != 0) { + break label_1; + } + local15 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + local16 = memory.readInt((int) local15 < 0 ? local15 : local15 + 28); + local17 = 1; + local18 = local16; + local19 = local17; + local20 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local19, local18); + local21 = 1; + local22 = (local20 & local21); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local22) != 0) { + break label_2; + } + local23 = memory.readInt((int) local6 < 0 ? local6 : local6 + 0); + local24 = memory.readInt((int) local6 < 0 ? local6 : local6 + 8); + memory.writeI32((int) local24 < 0 ? local24 : local24 + 28, (int) local23); + } + } + return; + } + + public static long[] call_1765(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + Wat2WasmMachine.func_1765(arg0, arg1, arg2, arg3, memory, instance); + return null; + } + + public static void func_1766(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + int local84 = 0; + int local85 = 0; + int local86 = 0; + int local87 = 0; + int local88 = 0; + int local89 = 0; + int local90 = 0; + int local91 = 0; + int local92 = 0; + int local93 = 0; + int local94 = 0; + int local95 = 0; + int local96 = 0; + int local97 = 0; + int local98 = 0; + int local99 = 0; + int local100 = 0; + int local101 = 0; + int local102 = 0; + int local103 = 0; + int local104 = 0; + int local105 = 0; + int local106 = 0; + int local107 = 0; + int local108 = 0; + int local109 = 0; + int local110 = 0; + int local111 = 0; + int local112 = 0; + int local113 = 0; + int local114 = 0; + int local115 = 0; + int local116 = 0; + int local117 = 0; + int local118 = 0; + int local119 = 0; + int local120 = 0; + int local121 = 0; + int local122 = 0; + int local123 = 0; + int local124 = 0; + int local125 = 0; + int local126 = 0; + int local127 = 0; + int local128 = 0; + int local129 = 0; + int local130 = 0; + int local131 = 0; + int local132 = 0; + int local133 = 0; + int local134 = 0; + int local135 = 0; + int local136 = 0; + int local137 = 0; + int local138 = 0; + int local139 = 0; + int local140 = 0; + int local141 = 0; + int local142 = 0; + int local143 = 0; + int local144 = 0; + int local145 = 0; + int local146 = 0; + int local147 = 0; + int local148 = 0; + int local149 = 0; + int local150 = 0; + int local151 = 0; + int local152 = 0; + int local153 = 0; + int local154 = 0; + int local155 = 0; + int local156 = 0; + int local157 = 0; + int local158 = 0; + int local159 = 0; + int local160 = 0; + int local161 = 0; + int local162 = 0; + int local163 = 0; + int local164 = 0; + int local165 = 0; + int local166 = 0; + int local167 = 0; + int local168 = 0; + int local169 = 0; + int local170 = 0; + int local171 = 0; + int local172 = 0; + int local173 = 0; + int local174 = 0; + int local175 = 0; + int local176 = 0; + int local177 = 0; + int local178 = 0; + int local179 = 0; + int local180 = 0; + int local181 = 0; + int local182 = 0; + int local183 = 0; + int local184 = 0; + int local185 = 0; + int local186 = 0; + int local187 = 0; + int local188 = 0; + int local189 = 0; + int local190 = 0; + int local191 = 0; + int local192 = 0; + int local193 = 0; + int local194 = 0; + int local195 = 0; + int local196 = 0; + int local197 = 0; + int local198 = 0; + int local199 = 0; + int local200 = 0; + int local201 = 0; + int local202 = 0; + int local203 = 0; + int local204 = 0; + int local205 = 0; + int local206 = 0; + int local207 = 0; + int local208 = 0; + int local209 = 0; + int local210 = 0; + int local211 = 0; + int local212 = 0; + int local213 = 0; + int local214 = 0; + int local215 = 0; + int local216 = 0; + int local217 = 0; + int local218 = 0; + int local219 = 0; + int local220 = 0; + int local221 = 0; + int local222 = 0; + int local223 = 0; + int local224 = 0; + int local225 = 0; + int local226 = 0; + int local227 = 0; + int local228 = 0; + int local229 = 0; + int local230 = 0; + int local231 = 0; + int local232 = 0; + int local233 = 0; + int local234 = 0; + int local235 = 0; + int local236 = 0; + int local237 = 0; + int local238 = 0; + int local239 = 0; + int local240 = 0; + int local241 = 0; + int local242 = 0; + int local243 = 0; + int local244 = 0; + int local245 = 0; + int local246 = 0; + int local247 = 0; + int local248 = 0; + int local249 = 0; + int local250 = 0; + int local251 = 0; + int local252 = 0; + int local253 = 0; + int local254 = 0; + int local255 = 0; + int local256 = 0; + int local257 = 0; + int local258 = 0; + int local259 = 0; + int local260 = 0; + int local261 = 0; + int local262 = 0; + int local263 = 0; + int local264 = 0; + int local265 = 0; + int local266 = 0; + int local267 = 0; + int local268 = 0; + int local269 = 0; + int local270 = 0; + int local271 = 0; + int local272 = 0; + int local273 = 0; + int local274 = 0; + int local275 = 0; + int local276 = 0; + int local277 = 0; + int local278 = 0; + int local279 = 0; + int local280 = 0; + int local281 = 0; + local5 = ((int) instance.global(0).getValue()); + local6 = 48; + local7 = (local5 - local6); + instance.global(0).setValue(((long) local7)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 44, (int) arg0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 40, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 36, (int) arg2); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 32, (int) arg3); + local8 = arg4; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 31, (byte) (local8)); + local9 = memory.readInt((int) local7 < 0 ? local7 : local7 + 44); + local10 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local11 = memory.readInt((int) local10 < 0 ? local10 : local10 + 8); + local12 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 31) & 0xFF); + local13 = 1; + local14 = (local12 & local13); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local14); + callArgs_0[1] = ((long) local11); + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local15 = ((int) callResult_0[0]); + local16 = 1; + local17 = (local15 & local16); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local17) != 0) { + break label_2; + } + local18 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local19 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + local20 = memory.readInt((int) local7 < 0 ? local7 : local7 + 32); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local20); + callArgs_1[2] = ((long) local19); + callArgs_1[1] = ((long) local18); + callArgs_1[0] = ((long) local9); + instance.getMachine().call(1765, callArgs_1); + break label_1; + } + local21 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local22 = memory.readInt((int) local21 < 0 ? local21 : local21 + 0); + local23 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 31) & 0xFF); + local24 = 1; + local25 = (local23 & local24); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local25); + callArgs_2[1] = ((long) local22); + callArgs_2[0] = ((long) local9); + long[] callResult_2 = instance.getMachine().call(1753, callArgs_2); + local26 = ((int) callResult_2[0]); + local27 = 1; + local28 = (local26 & local27); + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local28) != 0) { + break label_4; + } + local29 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + local30 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local31 = memory.readInt((int) local30 < 0 ? local30 : local30 + 16); + local32 = local29; + local33 = local31; + local34 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local33, local32); + local35 = 1; + local36 = (local34 & local35); + label_5: { + label_6: { + label_7: { + if (local36 != 0) { + break label_7; + } + local37 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + local38 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local39 = memory.readInt((int) local38 < 0 ? local38 : local38 + 20); + local40 = local37; + local41 = local39; + local42 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local41, local40); + local43 = 1; + local44 = (local42 & local43); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local44) != 0) { + break label_6; + } + } + local45 = memory.readInt((int) local7 < 0 ? local7 : local7 + 32); + local46 = 1; + local47 = local45; + local48 = local46; + local49 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local48, local47); + local50 = 1; + local51 = (local49 & local50); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local51) != 0) { + break label_8; + } + local52 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local53 = 1; + memory.writeI32((int) local52 < 0 ? local52 : local52 + 32, (int) local53); + } + break label_5; + } + local54 = memory.readInt((int) local7 < 0 ? local7 : local7 + 32); + local55 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + memory.writeI32((int) local55 < 0 ? local55 : local55 + 32, (int) local54); + local56 = 0; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 30, (byte) (local56)); + local57 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local58 = memory.readInt((int) local57 < 0 ? local57 : local57 + 44); + local59 = 4; + local60 = local58; + local61 = local59; + local62 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local61, local60); + local63 = 1; + local64 = (local62 & local63); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local64) != 0) { + break label_9; + } + local65 = 0; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 29, (byte) (local65)); + local66 = 16; + local67 = (local9 + local66); + local68 = memory.readInt((int) local9 < 0 ? local9 : local9 + 12); + local69 = 3; + local70 = (local68 << local69); + local71 = (local67 + local70); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 24, (int) local71); + local72 = 16; + local73 = (local9 + local72); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 20, (int) local73); + label_10: { + label_11: while (true) { + local74 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local75 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local76 = local74; + local77 = local75; + local78 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local76, local77); + local79 = 1; + local80 = (local78 & local79); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local80) != 0) { + break label_10; + } + local81 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local82 = 0; + memory.writeByte((int) local81 < 0 ? local81 : local81 + 52, (byte) (local82)); + local83 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local84 = 0; + memory.writeByte((int) local83 < 0 ? local83 : local83 + 53, (byte) (local84)); + local85 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local86 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local87 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + local88 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + local89 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 31) & 0xFF); + local90 = 1; + local91 = 1; + local92 = (local89 & local91); + long[] callArgs_3 = new long[6]; + callArgs_3[5] = ((long) local92); + callArgs_3[4] = ((long) local90); + callArgs_3[3] = ((long) local88); + callArgs_3[2] = ((long) local87); + callArgs_3[1] = ((long) local86); + callArgs_3[0] = ((long) local85); + instance.getMachine().call(1767, callArgs_3); + local93 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local94 = ((int) memory.read((int) local93 < 0 ? local93 : local93 + 54) & 0xFF); + local95 = 1; + local96 = (local94 & local95); + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local96) != 0) { + break label_12; + } + break label_10; + } + local97 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local98 = ((int) memory.read((int) local97 < 0 ? local97 : local97 + 53) & 0xFF); + local99 = 1; + local100 = (local98 & local99); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local100) != 0) { + break label_13; + } + local101 = 1; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 29, (byte) (local101)); + local102 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local103 = ((int) memory.read((int) local102 < 0 ? local102 : local102 + 52) & 0xFF); + local104 = 1; + local105 = (local103 & local104); + label_14: { + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local105) != 0) { + break label_15; + } + local106 = 1; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 30, (byte) (local106)); + local107 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local108 = memory.readInt((int) local107 < 0 ? local107 : local107 + 24); + local109 = 1; + local110 = local108; + local111 = local109; + local112 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local111, local110); + local113 = 1; + local114 = (local112 & local113); + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local114) != 0) { + break label_16; + } + break label_10; + } + local115 = memory.readInt((int) local9 < 0 ? local9 : local9 + 8); + local116 = 2; + local117 = (local115 & local116); + label_17: { + if (local117 != 0) { + break label_17; + } + break label_10; + } + break label_14; + } + local118 = memory.readInt((int) local9 < 0 ? local9 : local9 + 8); + local119 = 1; + local120 = (local118 & local119); + label_18: { + if (local120 != 0) { + break label_18; + } + break label_10; + } + } + } + local121 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local122 = 8; + local123 = (local121 + local122); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 20, (int) local123); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + } + local124 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 29) & 0xFF); + local125 = 1; + local126 = (local124 & local125); + label_19: { + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local126) != 0) { + break label_20; + } + local127 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local128 = 3; + memory.writeI32((int) local127 < 0 ? local127 : local127 + 44, (int) local128); + break label_19; + } + local129 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local130 = 4; + memory.writeI32((int) local129 < 0 ? local129 : local129 + 44, (int) local130); + } + } + local131 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 30) & 0xFF); + local132 = 1; + local133 = (local131 & local132); + label_21: { + if (local133 != 0) { + break label_21; + } + local134 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + local135 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + memory.writeI32((int) local135 < 0 ? local135 : local135 + 20, (int) local134); + local136 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local137 = memory.readInt((int) local136 < 0 ? local136 : local136 + 40); + local138 = 1; + local139 = (local137 + local138); + memory.writeI32((int) local136 < 0 ? local136 : local136 + 40, (int) local139); + local140 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local141 = memory.readInt((int) local140 < 0 ? local140 : local140 + 36); + local142 = 1; + local143 = local141; + local144 = local142; + local145 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local144, local143); + local146 = 1; + local147 = (local145 & local146); + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local147) != 0) { + break label_22; + } + local148 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local149 = memory.readInt((int) local148 < 0 ? local148 : local148 + 24); + local150 = 2; + local151 = local149; + local152 = local150; + local153 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local152, local151); + local154 = 1; + local155 = (local153 & local154); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local155) != 0) { + break label_22; + } + local156 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local157 = 1; + memory.writeByte((int) local156 < 0 ? local156 : local156 + 54, (byte) (local157)); + } + } + } + break label_3; + } + local158 = 16; + local159 = (local9 + local158); + local160 = memory.readInt((int) local9 < 0 ? local9 : local9 + 12); + local161 = 3; + local162 = (local160 << local161); + local163 = (local159 + local162); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 16, (int) local163); + local164 = 16; + local165 = (local9 + local164); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local165); + local166 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local167 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local168 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + local169 = memory.readInt((int) local7 < 0 ? local7 : local7 + 32); + local170 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 31) & 0xFF); + local171 = 1; + local172 = (local170 & local171); + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) local172); + callArgs_4[3] = ((long) local169); + callArgs_4[2] = ((long) local168); + callArgs_4[1] = ((long) local167); + callArgs_4[0] = ((long) local166); + instance.getMachine().call(1768, callArgs_4); + local173 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local174 = 8; + local175 = (local173 + local174); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local175); + local176 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local177 = local175; + local178 = local176; + local179 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local177, local178); + local180 = 1; + local181 = (local179 & local180); + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local181) != 0) { + break label_23; + } + local182 = memory.readInt((int) local9 < 0 ? local9 : local9 + 8); + local183 = 2; + local184 = (local182 & local183); + label_24: { + label_25: { + label_26: { + if (local184 != 0) { + break label_26; + } + local185 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local186 = memory.readInt((int) local185 < 0 ? local185 : local185 + 36); + local187 = 1; + local188 = local186; + local189 = local187; + local190 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local189, local188); + local191 = 1; + local192 = (local190 & local191); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local192) != 0) { + break label_25; + } + } + label_27: { + label_28: while (true) { + local193 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local194 = ((int) memory.read((int) local193 < 0 ? local193 : local193 + 54) & 0xFF); + local195 = 1; + local196 = (local194 & local195); + label_29: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local196) != 0) { + break label_29; + } + break label_27; + } + local197 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local198 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local199 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + local200 = memory.readInt((int) local7 < 0 ? local7 : local7 + 32); + local201 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 31) & 0xFF); + local202 = 1; + local203 = (local201 & local202); + long[] callArgs_5 = new long[5]; + callArgs_5[4] = ((long) local203); + callArgs_5[3] = ((long) local200); + callArgs_5[2] = ((long) local199); + callArgs_5[1] = ((long) local198); + callArgs_5[0] = ((long) local197); + instance.getMachine().call(1768, callArgs_5); + local204 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local205 = 8; + local206 = (local204 + local205); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local206); + local207 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local208 = local206; + local209 = local207; + local210 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local208, local209); + local211 = 1; + local212 = (local210 & local211); + if (local212 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_28; + } + break; + } + } + break label_24; + } + local213 = memory.readInt((int) local9 < 0 ? local9 : local9 + 8); + local214 = 1; + local215 = (local213 & local214); + label_30: { + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local215) != 0) { + break label_31; + } + label_32: { + label_33: while (true) { + local216 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local217 = ((int) memory.read((int) local216 < 0 ? local216 : local216 + 54) & 0xFF); + local218 = 1; + local219 = (local217 & local218); + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local219) != 0) { + break label_34; + } + break label_32; + } + local220 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local221 = memory.readInt((int) local220 < 0 ? local220 : local220 + 36); + local222 = 1; + local223 = local221; + local224 = local222; + local225 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local224, local223); + local226 = 1; + local227 = (local225 & local226); + label_35: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local227) != 0) { + break label_35; + } + local228 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local229 = memory.readInt((int) local228 < 0 ? local228 : local228 + 24); + local230 = 1; + local231 = local229; + local232 = local230; + local233 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local232, local231); + local234 = 1; + local235 = (local233 & local234); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local235) != 0) { + break label_35; + } + break label_32; + } + local236 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local237 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local238 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + local239 = memory.readInt((int) local7 < 0 ? local7 : local7 + 32); + local240 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 31) & 0xFF); + local241 = 1; + local242 = (local240 & local241); + long[] callArgs_6 = new long[5]; + callArgs_6[4] = ((long) local242); + callArgs_6[3] = ((long) local239); + callArgs_6[2] = ((long) local238); + callArgs_6[1] = ((long) local237); + callArgs_6[0] = ((long) local236); + instance.getMachine().call(1768, callArgs_6); + local243 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local244 = 8; + local245 = (local243 + local244); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local245); + local246 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local247 = local245; + local248 = local246; + local249 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local247, local248); + local250 = 1; + local251 = (local249 & local250); + if (local251 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_33; + } + break; + } + } + break label_30; + } + label_36: { + label_37: while (true) { + local252 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local253 = ((int) memory.read((int) local252 < 0 ? local252 : local252 + 54) & 0xFF); + local254 = 1; + local255 = (local253 & local254); + label_38: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local255) != 0) { + break label_38; + } + break label_36; + } + local256 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local257 = memory.readInt((int) local256 < 0 ? local256 : local256 + 36); + local258 = 1; + local259 = local257; + local260 = local258; + local261 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local260, local259); + local262 = 1; + local263 = (local261 & local262); + label_39: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local263) != 0) { + break label_39; + } + break label_36; + } + local264 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local265 = memory.readInt((int) local7 < 0 ? local7 : local7 + 40); + local266 = memory.readInt((int) local7 < 0 ? local7 : local7 + 36); + local267 = memory.readInt((int) local7 < 0 ? local7 : local7 + 32); + local268 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 31) & 0xFF); + local269 = 1; + local270 = (local268 & local269); + long[] callArgs_7 = new long[5]; + callArgs_7[4] = ((long) local270); + callArgs_7[3] = ((long) local267); + callArgs_7[2] = ((long) local266); + callArgs_7[1] = ((long) local265); + callArgs_7[0] = ((long) local264); + instance.getMachine().call(1768, callArgs_7); + local271 = memory.readInt((int) local7 < 0 ? local7 : local7 + 12); + local272 = 8; + local273 = (local271 + local272); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 12, (int) local273); + local274 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local275 = local273; + local276 = local274; + local277 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local275, local276); + local278 = 1; + local279 = (local277 & local278); + if (local279 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_37; + } + break; + } + } + } + } + } + } + } + local280 = 48; + local281 = (local7 + local280); + instance.global(0).setValue(((long) local281)); + return; + } + + public static long[] call_1766(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_1766(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static void func_1767(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + local6 = ((int) instance.global(0).getValue()); + local7 = 32; + local8 = (local6 - local7); + instance.global(0).setValue(((long) local8)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 28, (int) arg0); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 24, (int) arg1); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 20, (int) arg2); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 16, (int) arg3); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 12, (int) arg4); + local9 = arg5; + memory.writeByte((int) local8 < 0 ? local8 : local8 + 11, (byte) (local9)); + local10 = memory.readInt((int) local8 < 0 ? local8 : local8 + 28); + local11 = memory.readInt((int) local10 < 0 ? local10 : local10 + 4); + local12 = 8; + local13 = (local11 >> local12); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 4, (int) local13); + local14 = memory.readInt((int) local10 < 0 ? local10 : local10 + 4); + local15 = 1; + local16 = (local14 & local15); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local16) != 0) { + break label_1; + } + local17 = memory.readInt((int) local8 < 0 ? local8 : local8 + 16); + local18 = memory.readInt((int) local17 < 0 ? local17 : local17 + 0); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local18); + local19 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local20 = memory.readInt((int) local8 < 0 ? local8 : local8 + 4); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local20); + callArgs_0[0] = ((long) local19); + long[] callResult_0 = instance.getMachine().call(1762, callArgs_0); + local21 = ((int) callResult_0[0]); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 4, (int) local21); + } + local22 = memory.readInt((int) local10 < 0 ? local10 : local10 + 0); + local23 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local24 = memory.readInt((int) local8 < 0 ? local8 : local8 + 20); + local25 = memory.readInt((int) local8 < 0 ? local8 : local8 + 16); + local26 = memory.readInt((int) local8 < 0 ? local8 : local8 + 4); + local27 = (local25 + local26); + local28 = memory.readInt((int) local10 < 0 ? local10 : local10 + 4); + local29 = 2; + local30 = (local28 & local29); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local30) != 0) { + break label_3; + } + local31 = memory.readInt((int) local8 < 0 ? local8 : local8 + 12); + local32 = local31; + break label_2; + } + local33 = 2; + local32 = local33; + } + local34 = local32; + local35 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + local36 = memory.readInt((int) local22 < 0 ? local22 : local22 + 0); + local37 = memory.readInt((int) local36 < 0 ? local36 : local36 + 20); + local38 = 1; + local39 = (local35 & local38); + int ciTableIdx_1 = (int) (local37); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(17))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[6]; + callArgs_1[5] = ((long) local39); + callArgs_1[4] = ((long) local34); + callArgs_1[3] = ((long) local27); + callArgs_1[2] = ((long) local24); + callArgs_1[1] = ((long) local23); + callArgs_1[0] = ((long) local22); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local40 = 32; + local41 = (local8 + local40); + instance.global(0).setValue(((long) local41)); + return; + } + + public static long[] call_1767(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + Wat2WasmMachine.func_1767(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + return null; + } + + public static void func_1768(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + local5 = ((int) instance.global(0).getValue()); + local6 = 32; + local7 = (local5 - local6); + instance.global(0).setValue(((long) local7)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) arg0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 24, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 20, (int) arg2); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 16, (int) arg3); + local8 = arg4; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 15, (byte) (local8)); + local9 = memory.readInt((int) local7 < 0 ? local7 : local7 + 28); + local10 = memory.readInt((int) local9 < 0 ? local9 : local9 + 4); + local11 = 8; + local12 = (local10 >> local11); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 8, (int) local12); + local13 = memory.readInt((int) local9 < 0 ? local9 : local9 + 4); + local14 = 1; + local15 = (local13 & local14); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local15) != 0) { + break label_1; + } + local16 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local17 = memory.readInt((int) local16 < 0 ? local16 : local16 + 0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 4, (int) local17); + local18 = memory.readInt((int) local7 < 0 ? local7 : local7 + 4); + local19 = memory.readInt((int) local7 < 0 ? local7 : local7 + 8); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local19); + callArgs_0[0] = ((long) local18); + long[] callResult_0 = instance.getMachine().call(1762, callArgs_0); + local20 = ((int) callResult_0[0]); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 8, (int) local20); + } + local21 = memory.readInt((int) local9 < 0 ? local9 : local9 + 0); + local22 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local23 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local24 = memory.readInt((int) local7 < 0 ? local7 : local7 + 8); + local25 = (local23 + local24); + local26 = memory.readInt((int) local9 < 0 ? local9 : local9 + 4); + local27 = 2; + local28 = (local26 & local27); + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local28) != 0) { + break label_3; + } + local29 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local30 = local29; + break label_2; + } + local31 = 2; + local30 = local31; + } + local32 = local30; + local33 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 15) & 0xFF); + local34 = memory.readInt((int) local21 < 0 ? local21 : local21 + 0); + local35 = memory.readInt((int) local34 < 0 ? local34 : local34 + 24); + local36 = 1; + local37 = (local33 & local36); + int ciTableIdx_1 = (int) (local35); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(18))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) local37); + callArgs_1[3] = ((long) local32); + callArgs_1[2] = ((long) local25); + callArgs_1[1] = ((long) local22); + callArgs_1[0] = ((long) local21); + ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local38 = 32; + local39 = (local7 + local38); + instance.global(0).setValue(((long) local39)); + return; + } + + public static long[] call_1768(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_1768(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static void func_1769(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + int local84 = 0; + int local85 = 0; + int local86 = 0; + int local87 = 0; + int local88 = 0; + int local89 = 0; + int local90 = 0; + int local91 = 0; + int local92 = 0; + int local93 = 0; + int local94 = 0; + int local95 = 0; + int local96 = 0; + int local97 = 0; + int local98 = 0; + int local99 = 0; + int local100 = 0; + int local101 = 0; + int local102 = 0; + int local103 = 0; + int local104 = 0; + int local105 = 0; + int local106 = 0; + int local107 = 0; + int local108 = 0; + int local109 = 0; + int local110 = 0; + int local111 = 0; + int local112 = 0; + int local113 = 0; + int local114 = 0; + int local115 = 0; + int local116 = 0; + int local117 = 0; + int local118 = 0; + int local119 = 0; + int local120 = 0; + int local121 = 0; + int local122 = 0; + int local123 = 0; + int local124 = 0; + int local125 = 0; + int local126 = 0; + int local127 = 0; + int local128 = 0; + int local129 = 0; + int local130 = 0; + int local131 = 0; + int local132 = 0; + int local133 = 0; + int local134 = 0; + local5 = ((int) instance.global(0).getValue()); + local6 = 32; + local7 = (local5 - local6); + instance.global(0).setValue(((long) local7)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) arg0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 24, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 20, (int) arg2); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 16, (int) arg3); + local8 = arg4; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 15, (byte) (local8)); + local9 = memory.readInt((int) local7 < 0 ? local7 : local7 + 28); + local10 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local11 = memory.readInt((int) local10 < 0 ? local10 : local10 + 8); + local12 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 15) & 0xFF); + local13 = 1; + local14 = (local12 & local13); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local14); + callArgs_0[1] = ((long) local11); + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local15 = ((int) callResult_0[0]); + local16 = 1; + local17 = (local15 & local16); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local17) != 0) { + break label_2; + } + local18 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local19 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local20 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local20); + callArgs_1[2] = ((long) local19); + callArgs_1[1] = ((long) local18); + callArgs_1[0] = ((long) local9); + instance.getMachine().call(1765, callArgs_1); + break label_1; + } + local21 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local22 = memory.readInt((int) local21 < 0 ? local21 : local21 + 0); + local23 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 15) & 0xFF); + local24 = 1; + local25 = (local23 & local24); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local25); + callArgs_2[1] = ((long) local22); + callArgs_2[0] = ((long) local9); + long[] callResult_2 = instance.getMachine().call(1753, callArgs_2); + local26 = ((int) callResult_2[0]); + local27 = 1; + local28 = (local26 & local27); + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local28) != 0) { + break label_4; + } + local29 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local30 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local31 = memory.readInt((int) local30 < 0 ? local30 : local30 + 16); + local32 = local29; + local33 = local31; + local34 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local33, local32); + local35 = 1; + local36 = (local34 & local35); + label_5: { + label_6: { + label_7: { + if (local36 != 0) { + break label_7; + } + local37 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local38 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local39 = memory.readInt((int) local38 < 0 ? local38 : local38 + 20); + local40 = local37; + local41 = local39; + local42 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local41, local40); + local43 = 1; + local44 = (local42 & local43); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local44) != 0) { + break label_6; + } + } + local45 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local46 = 1; + local47 = local45; + local48 = local46; + local49 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local48, local47); + local50 = 1; + local51 = (local49 & local50); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local51) != 0) { + break label_8; + } + local52 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local53 = 1; + memory.writeI32((int) local52 < 0 ? local52 : local52 + 32, (int) local53); + } + break label_5; + } + local54 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local55 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + memory.writeI32((int) local55 < 0 ? local55 : local55 + 32, (int) local54); + local56 = 0; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 14, (byte) (local56)); + local57 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local58 = memory.readInt((int) local57 < 0 ? local57 : local57 + 44); + local59 = 4; + local60 = local58; + local61 = local59; + local62 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local61, local60); + local63 = 1; + local64 = (local62 & local63); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local64) != 0) { + break label_9; + } + local65 = 0; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 13, (byte) (local65)); + local66 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local67 = 0; + memory.writeByte((int) local66 < 0 ? local66 : local66 + 52, (byte) (local67)); + local68 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local69 = 0; + memory.writeByte((int) local68 < 0 ? local68 : local68 + 53, (byte) (local69)); + local70 = memory.readInt((int) local9 < 0 ? local9 : local9 + 8); + local71 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local72 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local73 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local74 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 15) & 0xFF); + local75 = memory.readInt((int) local70 < 0 ? local70 : local70 + 0); + local76 = memory.readInt((int) local75 < 0 ? local75 : local75 + 20); + local77 = 1; + local78 = 1; + local79 = (local74 & local78); + int ciTableIdx_3 = (int) (local76); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(17))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[6]; + callArgs_3[5] = ((long) local79); + callArgs_3[4] = ((long) local77); + callArgs_3[3] = ((long) local73); + callArgs_3[2] = ((long) local72); + callArgs_3[1] = ((long) local71); + callArgs_3[0] = ((long) local70); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + local80 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local81 = ((int) memory.read((int) local80 < 0 ? local80 : local80 + 53) & 0xFF); + local82 = 1; + local83 = (local81 & local82); + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local83) != 0) { + break label_10; + } + local84 = 1; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 13, (byte) (local84)); + local85 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local86 = ((int) memory.read((int) local85 < 0 ? local85 : local85 + 52) & 0xFF); + local87 = 1; + local88 = (local86 & local87); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local88) != 0) { + break label_11; + } + local89 = 1; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 14, (byte) (local89)); + } + } + local90 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 13) & 0xFF); + local91 = 1; + local92 = (local90 & local91); + label_12: { + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local92) != 0) { + break label_13; + } + local93 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local94 = 3; + memory.writeI32((int) local93 < 0 ? local93 : local93 + 44, (int) local94); + break label_12; + } + local95 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local96 = 4; + memory.writeI32((int) local95 < 0 ? local95 : local95 + 44, (int) local96); + } + } + local97 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 14) & 0xFF); + local98 = 1; + local99 = (local97 & local98); + label_14: { + if (local99 != 0) { + break label_14; + } + local100 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local101 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + memory.writeI32((int) local101 < 0 ? local101 : local101 + 20, (int) local100); + local102 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local103 = memory.readInt((int) local102 < 0 ? local102 : local102 + 40); + local104 = 1; + local105 = (local103 + local104); + memory.writeI32((int) local102 < 0 ? local102 : local102 + 40, (int) local105); + local106 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local107 = memory.readInt((int) local106 < 0 ? local106 : local106 + 36); + local108 = 1; + local109 = local107; + local110 = local108; + local111 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local110, local109); + local112 = 1; + local113 = (local111 & local112); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local113) != 0) { + break label_15; + } + local114 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local115 = memory.readInt((int) local114 < 0 ? local114 : local114 + 24); + local116 = 2; + local117 = local115; + local118 = local116; + local119 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local118, local117); + local120 = 1; + local121 = (local119 & local120); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local121) != 0) { + break label_15; + } + local122 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local123 = 1; + memory.writeByte((int) local122 < 0 ? local122 : local122 + 54, (byte) (local123)); + } + } + } + break label_3; + } + local124 = memory.readInt((int) local9 < 0 ? local9 : local9 + 8); + local125 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local126 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local127 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local128 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 15) & 0xFF); + local129 = memory.readInt((int) local124 < 0 ? local124 : local124 + 0); + local130 = memory.readInt((int) local129 < 0 ? local129 : local129 + 24); + local131 = 1; + local132 = (local128 & local131); + int ciTableIdx_4 = (int) (local130); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(18))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[5]; + callArgs_4[4] = ((long) local132); + callArgs_4[3] = ((long) local127); + callArgs_4[2] = ((long) local126); + callArgs_4[1] = ((long) local125); + callArgs_4[0] = ((long) local124); + ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + } + local133 = 32; + local134 = (local7 + local133); + instance.global(0).setValue(((long) local134)); + return; + } + + public static long[] call_1769(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_1769(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static void func_1770(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + local5 = ((int) instance.global(0).getValue()); + local6 = 32; + local7 = (local5 - local6); + instance.global(0).setValue(((long) local7)); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 28, (int) arg0); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 24, (int) arg1); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 20, (int) arg2); + memory.writeI32((int) local7 < 0 ? local7 : local7 + 16, (int) arg3); + local8 = arg4; + memory.writeByte((int) local7 < 0 ? local7 : local7 + 15, (byte) (local8)); + local9 = memory.readInt((int) local7 < 0 ? local7 : local7 + 28); + local10 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local11 = memory.readInt((int) local10 < 0 ? local10 : local10 + 8); + local12 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 15) & 0xFF); + local13 = 1; + local14 = (local12 & local13); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local14); + callArgs_0[1] = ((long) local11); + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local15 = ((int) callResult_0[0]); + local16 = 1; + local17 = (local15 & local16); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local17) != 0) { + break label_2; + } + local18 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local19 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local20 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) local20); + callArgs_1[2] = ((long) local19); + callArgs_1[1] = ((long) local18); + callArgs_1[0] = ((long) local9); + instance.getMachine().call(1765, callArgs_1); + break label_1; + } + local21 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local22 = memory.readInt((int) local21 < 0 ? local21 : local21 + 0); + local23 = ((int) memory.read((int) local7 < 0 ? local7 : local7 + 15) & 0xFF); + local24 = 1; + local25 = (local23 & local24); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local25); + callArgs_2[1] = ((long) local22); + callArgs_2[0] = ((long) local9); + long[] callResult_2 = instance.getMachine().call(1753, callArgs_2); + local26 = ((int) callResult_2[0]); + local27 = 1; + local28 = (local26 & local27); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local28) != 0) { + break label_3; + } + local29 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local30 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local31 = memory.readInt((int) local30 < 0 ? local30 : local30 + 16); + local32 = local29; + local33 = local31; + local34 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local33, local32); + local35 = 1; + local36 = (local34 & local35); + label_4: { + label_5: { + label_6: { + if (local36 != 0) { + break label_6; + } + local37 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local38 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local39 = memory.readInt((int) local38 < 0 ? local38 : local38 + 20); + local40 = local37; + local41 = local39; + local42 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local41, local40); + local43 = 1; + local44 = (local42 & local43); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local44) != 0) { + break label_5; + } + } + local45 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local46 = 1; + local47 = local45; + local48 = local46; + local49 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local48, local47); + local50 = 1; + local51 = (local49 & local50); + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local51) != 0) { + break label_7; + } + local52 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local53 = 1; + memory.writeI32((int) local52 < 0 ? local52 : local52 + 32, (int) local53); + } + break label_4; + } + local54 = memory.readInt((int) local7 < 0 ? local7 : local7 + 16); + local55 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + memory.writeI32((int) local55 < 0 ? local55 : local55 + 32, (int) local54); + local56 = memory.readInt((int) local7 < 0 ? local7 : local7 + 20); + local57 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + memory.writeI32((int) local57 < 0 ? local57 : local57 + 20, (int) local56); + local58 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local59 = memory.readInt((int) local58 < 0 ? local58 : local58 + 40); + local60 = 1; + local61 = (local59 + local60); + memory.writeI32((int) local58 < 0 ? local58 : local58 + 40, (int) local61); + local62 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local63 = memory.readInt((int) local62 < 0 ? local62 : local62 + 36); + local64 = 1; + local65 = local63; + local66 = local64; + local67 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local66, local65); + local68 = 1; + local69 = (local67 & local68); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local69) != 0) { + break label_8; + } + local70 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local71 = memory.readInt((int) local70 < 0 ? local70 : local70 + 24); + local72 = 2; + local73 = local71; + local74 = local72; + local75 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local74, local73); + local76 = 1; + local77 = (local75 & local76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local77) != 0) { + break label_8; + } + local78 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local79 = 1; + memory.writeByte((int) local78 < 0 ? local78 : local78 + 54, (byte) (local79)); + } + local80 = memory.readInt((int) local7 < 0 ? local7 : local7 + 24); + local81 = 4; + memory.writeI32((int) local80 < 0 ? local80 : local80 + 44, (int) local81); + } + } + } + local82 = 32; + local83 = (local7 + local82); + instance.global(0).setValue(((long) local83)); + return; + } + + public static long[] call_1770(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_1770(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static void func_1771(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + int local36 = 0; + int local37 = 0; + int local38 = 0; + int local39 = 0; + int local40 = 0; + int local41 = 0; + int local42 = 0; + int local43 = 0; + int local44 = 0; + int local45 = 0; + int local46 = 0; + int local47 = 0; + int local48 = 0; + int local49 = 0; + int local50 = 0; + int local51 = 0; + int local52 = 0; + int local53 = 0; + int local54 = 0; + int local55 = 0; + int local56 = 0; + int local57 = 0; + int local58 = 0; + int local59 = 0; + int local60 = 0; + int local61 = 0; + int local62 = 0; + int local63 = 0; + int local64 = 0; + int local65 = 0; + int local66 = 0; + int local67 = 0; + int local68 = 0; + int local69 = 0; + int local70 = 0; + int local71 = 0; + int local72 = 0; + int local73 = 0; + int local74 = 0; + int local75 = 0; + int local76 = 0; + int local77 = 0; + int local78 = 0; + int local79 = 0; + int local80 = 0; + int local81 = 0; + int local82 = 0; + int local83 = 0; + int local84 = 0; + int local85 = 0; + int local86 = 0; + int local87 = 0; + int local88 = 0; + int local89 = 0; + int local90 = 0; + int local91 = 0; + int local92 = 0; + int local93 = 0; + int local94 = 0; + int local95 = 0; + int local96 = 0; + int local97 = 0; + int local98 = 0; + int local99 = 0; + int local100 = 0; + int local101 = 0; + int local102 = 0; + int local103 = 0; + int local104 = 0; + int local105 = 0; + int local106 = 0; + int local107 = 0; + int local108 = 0; + int local109 = 0; + int local110 = 0; + int local111 = 0; + int local112 = 0; + int local113 = 0; + int local114 = 0; + int local115 = 0; + int local116 = 0; + int local117 = 0; + int local118 = 0; + int local119 = 0; + int local120 = 0; + int local121 = 0; + int local122 = 0; + int local123 = 0; + int local124 = 0; + int local125 = 0; + int local126 = 0; + int local127 = 0; + int local128 = 0; + int local129 = 0; + int local130 = 0; + int local131 = 0; + int local132 = 0; + int local133 = 0; + int local134 = 0; + int local135 = 0; + int local136 = 0; + int local137 = 0; + int local138 = 0; + int local139 = 0; + int local140 = 0; + int local141 = 0; + int local142 = 0; + int local143 = 0; + int local144 = 0; + int local145 = 0; + int local146 = 0; + int local147 = 0; + int local148 = 0; + int local149 = 0; + int local150 = 0; + int local151 = 0; + int local152 = 0; + int local153 = 0; + int local154 = 0; + int local155 = 0; + int local156 = 0; + int local157 = 0; + int local158 = 0; + int local159 = 0; + int local160 = 0; + int local161 = 0; + int local162 = 0; + int local163 = 0; + int local164 = 0; + int local165 = 0; + int local166 = 0; + int local167 = 0; + int local168 = 0; + int local169 = 0; + int local170 = 0; + int local171 = 0; + int local172 = 0; + local6 = ((int) instance.global(0).getValue()); + local7 = 32; + local8 = (local6 - local7); + instance.global(0).setValue(((long) local8)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 28, (int) arg0); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 24, (int) arg1); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 20, (int) arg2); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 16, (int) arg3); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 12, (int) arg4); + local9 = arg5; + memory.writeByte((int) local8 < 0 ? local8 : local8 + 11, (byte) (local9)); + local10 = memory.readInt((int) local8 < 0 ? local8 : local8 + 28); + local11 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local12 = memory.readInt((int) local11 < 0 ? local11 : local11 + 8); + local13 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + local14 = 1; + local15 = (local13 & local14); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local15); + callArgs_0[1] = ((long) local12); + callArgs_0[0] = ((long) local10); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local16 = ((int) callResult_0[0]); + local17 = 1; + local18 = (local16 & local17); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local18) != 0) { + break label_2; + } + local19 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local20 = memory.readInt((int) local8 < 0 ? local8 : local8 + 20); + local21 = memory.readInt((int) local8 < 0 ? local8 : local8 + 16); + local22 = memory.readInt((int) local8 < 0 ? local8 : local8 + 12); + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) local22); + callArgs_1[3] = ((long) local21); + callArgs_1[2] = ((long) local20); + callArgs_1[1] = ((long) local19); + callArgs_1[0] = ((long) local10); + instance.getMachine().call(1764, callArgs_1); + break label_1; + } + local23 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local24 = ((int) memory.read((int) local23 < 0 ? local23 : local23 + 52) & 0xFF); + local25 = 1; + local26 = (local24 & local25); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 10, (byte) (local26)); + local27 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local28 = ((int) memory.read((int) local27 < 0 ? local27 : local27 + 53) & 0xFF); + local29 = 1; + local30 = (local28 & local29); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 9, (byte) (local30)); + local31 = 16; + local32 = (local10 + local31); + local33 = memory.readInt((int) local10 < 0 ? local10 : local10 + 12); + local34 = 3; + local35 = (local33 << local34); + local36 = (local32 + local35); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 4, (int) local36); + local37 = 16; + local38 = (local10 + local37); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local38); + local39 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local40 = 0; + memory.writeByte((int) local39 < 0 ? local39 : local39 + 52, (byte) (local40)); + local41 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local42 = 0; + memory.writeByte((int) local41 < 0 ? local41 : local41 + 53, (byte) (local42)); + local43 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local44 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local45 = memory.readInt((int) local8 < 0 ? local8 : local8 + 20); + local46 = memory.readInt((int) local8 < 0 ? local8 : local8 + 16); + local47 = memory.readInt((int) local8 < 0 ? local8 : local8 + 12); + local48 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + local49 = 1; + local50 = (local48 & local49); + long[] callArgs_2 = new long[6]; + callArgs_2[5] = ((long) local50); + callArgs_2[4] = ((long) local47); + callArgs_2[3] = ((long) local46); + callArgs_2[2] = ((long) local45); + callArgs_2[1] = ((long) local44); + callArgs_2[0] = ((long) local43); + instance.getMachine().call(1767, callArgs_2); + local51 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local52 = ((int) memory.read((int) local51 < 0 ? local51 : local51 + 52) & 0xFF); + local53 = 1; + local54 = (local52 & local53); + local55 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 10) & 0xFF); + local56 = 1; + local57 = (local55 & local56); + local58 = (local57 | local54); + local59 = 0; + local60 = local58; + local61 = local59; + local62 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local61, local60); + local63 = 1; + local64 = (local62 & local63); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 10, (byte) (local64)); + local65 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local66 = ((int) memory.read((int) local65 < 0 ? local65 : local65 + 53) & 0xFF); + local67 = 1; + local68 = (local66 & local67); + local69 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 9) & 0xFF); + local70 = 1; + local71 = (local69 & local70); + local72 = (local71 | local68); + local73 = 0; + local74 = local72; + local75 = local73; + local76 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local75, local74); + local77 = 1; + local78 = (local76 & local77); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 9, (byte) (local78)); + local79 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local80 = 8; + local81 = (local79 + local80); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local81); + local82 = memory.readInt((int) local8 < 0 ? local8 : local8 + 4); + local83 = local81; + local84 = local82; + local85 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local83, local84); + local86 = 1; + local87 = (local85 & local86); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local87) != 0) { + break label_3; + } + label_4: { + label_5: while (true) { + local88 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local89 = ((int) memory.read((int) local88 < 0 ? local88 : local88 + 54) & 0xFF); + local90 = 1; + local91 = (local89 & local90); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local91) != 0) { + break label_6; + } + break label_4; + } + local92 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local93 = ((int) memory.read((int) local92 < 0 ? local92 : local92 + 52) & 0xFF); + local94 = 1; + local95 = (local93 & local94); + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local95) != 0) { + break label_8; + } + local96 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local97 = memory.readInt((int) local96 < 0 ? local96 : local96 + 24); + local98 = 1; + local99 = local97; + local100 = local98; + local101 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local100, local99); + local102 = 1; + local103 = (local101 & local102); + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local103) != 0) { + break label_9; + } + break label_4; + } + local104 = memory.readInt((int) local10 < 0 ? local10 : local10 + 8); + local105 = 2; + local106 = (local104 & local105); + label_10: { + if (local106 != 0) { + break label_10; + } + break label_4; + } + break label_7; + } + local107 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local108 = ((int) memory.read((int) local107 < 0 ? local107 : local107 + 53) & 0xFF); + local109 = 1; + local110 = (local108 & local109); + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local110) != 0) { + break label_11; + } + local111 = memory.readInt((int) local10 < 0 ? local10 : local10 + 8); + local112 = 1; + local113 = (local111 & local112); + label_12: { + if (local113 != 0) { + break label_12; + } + break label_4; + } + } + } + local114 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local115 = 0; + memory.writeByte((int) local114 < 0 ? local114 : local114 + 52, (byte) (local115)); + local116 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local117 = 0; + memory.writeByte((int) local116 < 0 ? local116 : local116 + 53, (byte) (local117)); + local118 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local119 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local120 = memory.readInt((int) local8 < 0 ? local8 : local8 + 20); + local121 = memory.readInt((int) local8 < 0 ? local8 : local8 + 16); + local122 = memory.readInt((int) local8 < 0 ? local8 : local8 + 12); + local123 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + local124 = 1; + local125 = (local123 & local124); + long[] callArgs_3 = new long[6]; + callArgs_3[5] = ((long) local125); + callArgs_3[4] = ((long) local122); + callArgs_3[3] = ((long) local121); + callArgs_3[2] = ((long) local120); + callArgs_3[1] = ((long) local119); + callArgs_3[0] = ((long) local118); + instance.getMachine().call(1767, callArgs_3); + local126 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local127 = ((int) memory.read((int) local126 < 0 ? local126 : local126 + 52) & 0xFF); + local128 = 1; + local129 = (local127 & local128); + local130 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 10) & 0xFF); + local131 = 1; + local132 = (local130 & local131); + local133 = (local132 | local129); + local134 = 0; + local135 = local133; + local136 = local134; + local137 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local136, local135); + local138 = 1; + local139 = (local137 & local138); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 10, (byte) (local139)); + local140 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local141 = ((int) memory.read((int) local140 < 0 ? local140 : local140 + 53) & 0xFF); + local142 = 1; + local143 = (local141 & local142); + local144 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 9) & 0xFF); + local145 = 1; + local146 = (local144 & local145); + local147 = (local146 | local143); + local148 = 0; + local149 = local147; + local150 = local148; + local151 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local150, local149); + local152 = 1; + local153 = (local151 & local152); + memory.writeByte((int) local8 < 0 ? local8 : local8 + 9, (byte) (local153)); + local154 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + local155 = 8; + local156 = (local154 + local155); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 0, (int) local156); + local157 = memory.readInt((int) local8 < 0 ? local8 : local8 + 4); + local158 = local156; + local159 = local157; + local160 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local158, local159); + local161 = 1; + local162 = (local160 & local161); + if (local162 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + } + local163 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 10) & 0xFF); + local164 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local165 = 1; + local166 = (local163 & local165); + memory.writeByte((int) local164 < 0 ? local164 : local164 + 52, (byte) (local166)); + local167 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 9) & 0xFF); + local168 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local169 = 1; + local170 = (local167 & local169); + memory.writeByte((int) local168 < 0 ? local168 : local168 + 53, (byte) (local170)); + } + local171 = 32; + local172 = (local8 + local171); + instance.global(0).setValue(((long) local172)); + return; + } + + public static long[] call_1771(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + Wat2WasmMachine.func_1771(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + return null; + } + + public static void func_1772(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + local6 = ((int) instance.global(0).getValue()); + local7 = 32; + local8 = (local6 - local7); + instance.global(0).setValue(((long) local8)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 28, (int) arg0); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 24, (int) arg1); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 20, (int) arg2); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 16, (int) arg3); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 12, (int) arg4); + local9 = arg5; + memory.writeByte((int) local8 < 0 ? local8 : local8 + 11, (byte) (local9)); + local10 = memory.readInt((int) local8 < 0 ? local8 : local8 + 28); + local11 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local12 = memory.readInt((int) local11 < 0 ? local11 : local11 + 8); + local13 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + local14 = 1; + local15 = (local13 & local14); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local15); + callArgs_0[1] = ((long) local12); + callArgs_0[0] = ((long) local10); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local16 = ((int) callResult_0[0]); + local17 = 1; + local18 = (local16 & local17); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local18) != 0) { + break label_2; + } + local19 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local20 = memory.readInt((int) local8 < 0 ? local8 : local8 + 20); + local21 = memory.readInt((int) local8 < 0 ? local8 : local8 + 16); + local22 = memory.readInt((int) local8 < 0 ? local8 : local8 + 12); + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) local22); + callArgs_1[3] = ((long) local21); + callArgs_1[2] = ((long) local20); + callArgs_1[1] = ((long) local19); + callArgs_1[0] = ((long) local10); + instance.getMachine().call(1764, callArgs_1); + break label_1; + } + local23 = memory.readInt((int) local10 < 0 ? local10 : local10 + 8); + local24 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local25 = memory.readInt((int) local8 < 0 ? local8 : local8 + 20); + local26 = memory.readInt((int) local8 < 0 ? local8 : local8 + 16); + local27 = memory.readInt((int) local8 < 0 ? local8 : local8 + 12); + local28 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + local29 = memory.readInt((int) local23 < 0 ? local23 : local23 + 0); + local30 = memory.readInt((int) local29 < 0 ? local29 : local29 + 20); + local31 = 1; + local32 = (local28 & local31); + int ciTableIdx_2 = (int) (local30); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(17))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[6]; + callArgs_2[5] = ((long) local32); + callArgs_2[4] = ((long) local27); + callArgs_2[3] = ((long) local26); + callArgs_2[2] = ((long) local25); + callArgs_2[1] = ((long) local24); + callArgs_2[0] = ((long) local23); + ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + } + local33 = 32; + local34 = (local8 + local33); + instance.global(0).setValue(((long) local34)); + return; + } + + public static long[] call_1772(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + Wat2WasmMachine.func_1772(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + return null; + } + + public static void func_1773(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + local6 = ((int) instance.global(0).getValue()); + local7 = 32; + local8 = (local6 - local7); + instance.global(0).setValue(((long) local8)); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 28, (int) arg0); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 24, (int) arg1); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 20, (int) arg2); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 16, (int) arg3); + memory.writeI32((int) local8 < 0 ? local8 : local8 + 12, (int) arg4); + local9 = arg5; + memory.writeByte((int) local8 < 0 ? local8 : local8 + 11, (byte) (local9)); + local10 = memory.readInt((int) local8 < 0 ? local8 : local8 + 28); + local11 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local12 = memory.readInt((int) local11 < 0 ? local11 : local11 + 8); + local13 = ((int) memory.read((int) local8 < 0 ? local8 : local8 + 11) & 0xFF); + local14 = 1; + local15 = (local13 & local14); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local15); + callArgs_0[1] = ((long) local12); + callArgs_0[0] = ((long) local10); + long[] callResult_0 = instance.getMachine().call(1753, callArgs_0); + local16 = ((int) callResult_0[0]); + local17 = 1; + local18 = (local16 & local17); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local18) != 0) { + break label_1; + } + local19 = memory.readInt((int) local8 < 0 ? local8 : local8 + 24); + local20 = memory.readInt((int) local8 < 0 ? local8 : local8 + 20); + local21 = memory.readInt((int) local8 < 0 ? local8 : local8 + 16); + local22 = memory.readInt((int) local8 < 0 ? local8 : local8 + 12); + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) local22); + callArgs_1[3] = ((long) local21); + callArgs_1[2] = ((long) local20); + callArgs_1[1] = ((long) local19); + callArgs_1[0] = ((long) local10); + instance.getMachine().call(1764, callArgs_1); + } + local23 = 32; + local24 = (local8 + local23); + instance.global(0).setValue(((long) local24)); + return; + } + + public static long[] call_1773(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int arg5 = ((int) args[5]); + Wat2WasmMachine.func_1773(arg0, arg1, arg2, arg3, arg4, arg5, memory, instance); + return null; + } + + public static int func_1774(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local6 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + return local6; + } + + public static long[] call_1774(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1774(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1775(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + int local1 = 0; + int local2 = 0; + local0 = 657684; + local1 = 2; + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local1); + callArgs_0[0] = ((long) local0); + long[] callResult_0 = instance.getMachine().call(1774, callArgs_0); + local2 = ((int) callResult_0[0]); + return local2; + } + + public static long[] call_1775(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int result = Wat2WasmMachine.func_1775(memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1776(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + label_1: { + if (local4 != 0) { + break label_1; + } + local5 = 1; + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local5); + } + label_2: { + label_3: while (true) { + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local6); + long[] callResult_0 = instance.getMachine().call(1782, callArgs_0); + local7 = ((int) callResult_0[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local7); + local8 = 0; + local9 = local7; + local10 = local8; + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local10, local9); + local12 = 1; + local13 = (local11 & local12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local13) != 0) { + break label_2; + } + long[] callResult_1 = instance.getMachine().call(1775, new long[0]); + local14 = ((int) callResult_1[0]); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local14); + local15 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + local16 = 0; + local17 = local15; + local18 = local16; + local19 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local18, local17); + local20 = 1; + local21 = (local19 & local20); + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local21) != 0) { + break label_5; + } + local22 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + int ciTableIdx_2 = (int) (local22); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(19))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + ciRefInstance_2.getMachine().call(ciFuncId_2, new long[0]); + break label_4; + } + break label_2; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + } + local23 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + local24 = 16; + local25 = (local3 + local24); + instance.global(0).setValue(((long) local25)); + return local23; + } + + public static long[] call_1776(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1776(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1777(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1784, callArgs_0); + local5 = 16; + local6 = (local3 + local5); + instance.global(0).setValue(((long) local6)); + return; + } + + public static long[] call_1777(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1777(arg0, memory, instance); + return null; + } + + public static int func_1778(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + int local31 = 0; + int local32 = 0; + int local33 = 0; + int local34 = 0; + int local35 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + label_1: { + if (local5 != 0) { + break label_1; + } + local6 = 1; + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local6); + } + local7 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local8 = 4; + local9 = local7; + local10 = local8; + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local9, local10); + local12 = 1; + local13 = (local11 & local12); + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local13) != 0) { + break label_2; + } + local14 = 4; + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local14); + } + label_3: { + label_4: while (true) { + local15 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local16 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local16); + callArgs_0[0] = ((long) local15); + long[] callResult_0 = instance.getMachine().call(1779, callArgs_0); + local17 = ((int) callResult_0[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local17); + local18 = 0; + local19 = local17; + local20 = local18; + local21 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local20, local19); + local22 = 1; + local23 = (local21 & local22); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local23) != 0) { + break label_3; + } + long[] callResult_1 = instance.getMachine().call(1775, new long[0]); + local24 = ((int) callResult_1[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local24); + local25 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local26 = 0; + local27 = local25; + local28 = local26; + local29 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local28, local27); + local30 = 1; + local31 = (local29 & local30); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local31) != 0) { + break label_6; + } + local32 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + int ciTableIdx_2 = (int) (local32); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(19))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + ciRefInstance_2.getMachine().call(ciFuncId_2, new long[0]); + break label_5; + } + break label_3; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + } + local33 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local34 = 16; + local35 = (local4 + local34); + instance.global(0).setValue(((long) local35)); + return local33; + } + + public static long[] call_1778(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1778(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1779(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + int local16 = 0; + int local17 = 0; + int local18 = 0; + int local19 = 0; + int local20 = 0; + int local21 = 0; + int local22 = 0; + int local23 = 0; + int local24 = 0; + int local25 = 0; + int local26 = 0; + int local27 = 0; + int local28 = 0; + int local29 = 0; + int local30 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local7 = (local5 + local6); + local8 = 1; + local9 = (local7 - local8); + local10 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local11 = 1; + local12 = (local10 - local11); + local13 = -1; + local14 = (local12 ^ local13); + local15 = (local9 & local14); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 4, (int) local15); + local16 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + local17 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local18 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local19 = local17; + local20 = local18; + local21 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local19, local20); + local22 = 1; + local23 = (local21 & local22); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local23) != 0) { + break label_2; + } + local24 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + local25 = local24; + break label_1; + } + local26 = memory.readInt((int) local4 < 0 ? local4 : local4 + 4); + local25 = local26; + } + local27 = local25; + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local27); + callArgs_0[0] = ((long) local16); + long[] callResult_0 = instance.getMachine().call(1789, callArgs_0); + local28 = ((int) callResult_0[0]); + local29 = 16; + local30 = (local4 + local29); + instance.global(0).setValue(((long) local30)); + return local28; + } + + public static long[] call_1779(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1779(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1780(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = ((int) instance.global(0).getValue()); + local3 = 16; + local4 = (local2 - local3); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg1); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local5); + instance.getMachine().call(1781, callArgs_0); + local6 = 16; + local7 = (local4 + local6); + instance.global(0).setValue(((long) local7)); + return; + } + + public static long[] call_1780(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1780(arg0, arg1, memory, instance); + return null; + } + + public static void func_1781(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + local1 = ((int) instance.global(0).getValue()); + local2 = 16; + local3 = (local1 - local2); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg0); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local4); + instance.getMachine().call(1784, callArgs_0); + local5 = 16; + local6 = (local3 + local5); + instance.global(0).setValue(((long) local6)); + return; + } + + public static long[] call_1781(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1781(arg0, memory, instance); + return null; + } + + public static int func_1782(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1783, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_1782(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1782(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1783(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[14]; + iL[0] = arg0; + iL[3] = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) iL[3])); + label_1: { + iL[4] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657712); + if (iL[4] != 0) { + break label_1; + } + label_2: { + label_3: { + iL[5] = memory.readInt((int) 0 < 0 ? 0 : 0 + 658160); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_3; + } + iL[6] = memory.readInt((int) 0 < 0 ? 0 : 0 + 658164); + break label_2; + } + memory.writeLong((int) 0 < 0 ? 0 : 0 + 658172, (long) -1L); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 658164, (long) 281474976776192L); + iL[5] = (((iL[3] + 8) & -16) ^ 1431655768); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658160, (int) iL[5]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658180, (int) 0); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658132, (int) 0); + iL[6] = 65536; + } + iL[4] = 0; + iL[7] = ((786432 != 0 ? 786432 : (((726144 + iL[6]) + -1) & (0 - iL[6]))) - 726144); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[7], 89) != 0) { + break label_1; + } + iL[6] = 0; + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658140, (int) iL[7]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658136, (int) 726144); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657704, (int) 726144); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657724, (int) iL[5]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657720, (int) -1); + label_4: while (true) { + iL[5] = (iL[6] + 657736); + memory.writeI32((int) (iL[6] + 657748) < 0 ? (iL[6] + 657748) : (iL[6] + 657748) + 0, (int) iL[5]); + iL[8] = (iL[6] + 657728); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) iL[8]); + memory.writeI32((int) (iL[6] + 657740) < 0 ? (iL[6] + 657740) : (iL[6] + 657740) + 0, (int) iL[8]); + iL[8] = (iL[6] + 657744); + memory.writeI32((int) (iL[6] + 657756) < 0 ? (iL[6] + 657756) : (iL[6] + 657756) + 0, (int) iL[8]); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) iL[5]); + iL[5] = (iL[6] + 657752); + memory.writeI32((int) (iL[6] + 657764) < 0 ? (iL[6] + 657764) : (iL[6] + 657764) + 0, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) iL[8]); + memory.writeI32((int) (iL[6] + 657760) < 0 ? (iL[6] + 657760) : (iL[6] + 657760) + 0, (int) iL[5]); + iL[6] = (iL[6] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(256, iL[6]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + iL[6] = (((726144 + 8) & 15) != 0 ? ((-8 - 726144) & 15) : 0); + iL[4] = (726144 + iL[6]); + iL[5] = (iL[7] + -56); + iL[6] = (iL[5] - iL[6]); + memory.writeI32((int) (iL[4] + 4) < 0 ? (iL[4] + 4) : (iL[4] + 4) + 0, (int) (iL[6] | 1)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657716, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 658176)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657700, (int) iL[6]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657712, (int) iL[4]); + memory.writeI32((int) (726144 + iL[5]) < 0 ? (726144 + iL[5]) : (726144 + iL[5]) + 4, (int) 56); + } + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + int _d0 = func_1783__h0(iL, memory, instance); + if (_d0 == 1) + break label_5; + if (_d0 == 2) + break label_6; + if (_d0 == 3) + break label_7; + if (_d0 == 4) + break label_8; + } + iL[6] = (memory.readInt((int) 0 < 0 ? 0 : 0 + 658120) + iL[9]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658120, (int) iL[6]); + label_64: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[6], memory.readInt((int) 0 < 0 ? 0 : 0 + 658124)) != 0) { + break label_64; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658124, (int) iL[6]); + } + label_65: { + int _d1 = func_1783__h1(iL, memory, instance); + if (_d1 == 1) + break label_5; + } + iL[6] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657700); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[6], iL[7]) != 0) { + break label_8; + } + iL[5] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657712); + iL[8] = (iL[5] + iL[7]); + iL[6] = (iL[6] - iL[7]); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 4, (int) (iL[6] | 1)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657700, (int) iL[6]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657712, (int) iL[8]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 4, (int) (iL[7] | 3)); + iL[6] = (iL[5] + 8); + break label_5; + } + iL[6] = 0; + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 48); + break label_5; + } + label_110: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_110; + } + label_111: { + label_112: { + iL[8] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 28); + iL[6] = ((iL[8] << 2) + 657992); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0), iL[11]) != 0) { + break label_112; + } + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (int) iL[0]); + if (iL[0] != 0) { + break label_111; + } + iL[12] = (iL[12] & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, iL[8])); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) iL[12]); + break label_110; + } + memory.writeI32((int) (iL[4] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[11], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 16)) != 0 ? 16 : 20)) < 0 ? (iL[4] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[11], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 16)) != 0 ? 16 : 20)) : (iL[4] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[11], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 16)) != 0 ? 16 : 20)) + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_110; + } + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 24, (int) iL[4]); + label_113: { + iL[6] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_113; + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 16, (int) iL[6]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 24, (int) iL[0]); + } + iL[6] = memory.readInt((int) (iL[11] + 20) < 0 ? (iL[11] + 20) : (iL[11] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_110; + } + memory.writeI32((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (int) iL[6]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 24, (int) iL[0]); + } + label_114: { + label_115: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[5], 15) != 0) { + break label_115; + } + iL[6] = (iL[5] + iL[7]); + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 4, (int) (iL[6] | 3)); + iL[6] = (iL[11] + iL[6]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 4, (int) (memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4) | 1)); + break label_114; + } + iL[0] = (iL[11] + iL[7]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (int) (iL[5] | 1)); + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 4, (int) (iL[7] | 3)); + memory.writeI32((int) (iL[0] + iL[5]) < 0 ? (iL[0] + iL[5]) : (iL[0] + iL[5]) + 0, (int) iL[5]); + label_116: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[5], 255) != 0) { + break label_116; + } + iL[6] = ((iL[5] & -8) + 657728); + label_117: { + label_118: { + iL[8] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657688); + iL[5] = (1 << (iL[5] >>> 3)); + if ((iL[8] & iL[5]) != 0) { + break label_118; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (iL[8] | iL[5])); + iL[5] = iL[6]; + break label_117; + } + iL[5] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 8); + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 12, (int) iL[0]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 8, (int) iL[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[6]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 8, (int) iL[5]); + break label_114; + } + iL[6] = 31; + label_119: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[5], 16777215) != 0) { + break label_119; + } + iL[6] = com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ((iL[5] >>> 8)); + iL[6] = ((((iL[5] >>> (38 - iL[6])) & 1) - (iL[6] << 1)) + 62); + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 28, (int) iL[6]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 16, (long) 0L); + iL[8] = ((iL[6] << 2) + 657992); + label_120: { + iL[7] = (1 << iL[6]); + if ((iL[12] & iL[7]) != 0) { + break label_120; + } + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) iL[0]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (iL[12] | iL[7])); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 24, (int) iL[8]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 8, (int) iL[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[0]); + break label_114; + } + iL[6] = (iL[5] << (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(31, iL[6]) != 0 ? 0 : (25 - (iL[6] >>> 1)))); + iL[7] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + label_121: { + label_122: while (true) { + iL[8] = iL[7]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[5], (memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 4) & -8)) != 0) { + break label_121; + } + iL[7] = (iL[6] >>> 29); + iL[6] = (iL[6] << 1); + iL[9] = ((iL[8] + (iL[7] & 4)) + 16); + iL[7] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0); + if (iL[7] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_122; + } + break; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) iL[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 24, (int) iL[8]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 8, (int) iL[0]); + break label_114; + } + iL[6] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 8); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 12, (int) iL[0]); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 8, (int) iL[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 24, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[8]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 8, (int) iL[6]); + } + iL[6] = (iL[11] + 8); + break label_5; + } + label_123: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_123; + } + label_124: { + label_125: { + iL[8] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 28); + iL[6] = ((iL[8] << 2) + 657992); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0), iL[0]) != 0) { + break label_125; + } + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (int) iL[11]); + if (iL[11] != 0) { + break label_124; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (iL[12] & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, iL[8]))); + break label_123; + } + memory.writeI32((int) (iL[13] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[0], memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 16)) != 0 ? 16 : 20)) < 0 ? (iL[13] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[0], memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 16)) != 0 ? 16 : 20)) : (iL[13] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[0], memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 16)) != 0 ? 16 : 20)) + 0, (int) iL[11]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[11]) != 0) { + break label_123; + } + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 24, (int) iL[13]); + label_126: { + iL[6] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_126; + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 16, (int) iL[6]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 24, (int) iL[11]); + } + iL[6] = memory.readInt((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_123; + } + memory.writeI32((int) (iL[11] + 20) < 0 ? (iL[11] + 20) : (iL[11] + 20) + 0, (int) iL[6]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 24, (int) iL[11]); + } + label_127: { + label_128: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[5], 15) != 0) { + break label_128; + } + iL[6] = (iL[5] + iL[7]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (int) (iL[6] | 3)); + iL[6] = (iL[0] + iL[6]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 4, (int) (memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4) | 1)); + break label_127; + } + iL[8] = (iL[0] + iL[7]); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 4, (int) (iL[5] | 1)); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (int) (iL[7] | 3)); + memory.writeI32((int) (iL[8] + iL[5]) < 0 ? (iL[8] + iL[5]) : (iL[8] + iL[5]) + 0, (int) iL[5]); + label_129: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[10]) != 0) { + break label_129; + } + iL[7] = ((iL[10] & -8) + 657728); + iL[6] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657708); + label_130: { + label_131: { + iL[11] = (1 << (iL[10] >>> 3)); + if ((iL[11] & iL[9]) != 0) { + break label_131; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (iL[11] | iL[9])); + iL[11] = iL[7]; + break label_130; + } + iL[11] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 8); + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 12, (int) iL[6]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 8, (int) iL[6]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 12, (int) iL[7]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 8, (int) iL[11]); + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657708, (int) iL[8]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) iL[5]); + } + iL[6] = (iL[0] + 8); + } + instance.global(0).setValue(((long) (iL[3] + 16))); + return iL[6]; + } + + public static long[] call_1783(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1783(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1784(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1785, callArgs_0); + return; + } + + public static long[] call_1784(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1784(arg0, memory, instance); + return null; + } + + public static void func_1785(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + local1 = (arg0 + -8); + local2 = memory.readInt((int) (arg0 + -4) < 0 ? (arg0 + -4) : (arg0 + -4) + 0); + arg0 = (local2 & -8); + local3 = (local1 + arg0); + label_2: { + if ((local2 & 1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local2 & 3)) != 0) { + break label_1; + } + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + local1 = (local1 - local2); + local4 = memory.readInt((int) 0 < 0 ? 0 : 0 + 657704); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, local4) != 0) { + break label_1; + } + arg0 = (local2 + arg0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) 0 < 0 ? 0 : 0 + 657708), local1) != 0) { + break label_3; + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 255) != 0) { + break label_4; + } + local4 = memory.readInt((int) local1 < 0 ? local1 : local1 + 8); + local5 = (local2 >>> 3); + local6 = ((local5 << 3) + 657728); + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4); + label_5: { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local2) != 0) { + break label_5; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 657688) & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, local5))); + break label_2; + } + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local2); + break label_2; + } + local7 = memory.readInt((int) local1 < 0 ? local1 : local1 + 24); + label_6: { + label_7: { + local6 = memory.readInt((int) local1 < 0 ? local1 : local1 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, local6) != 0) { + break label_7; + } + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 8); + com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, local4); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local6); + break label_6; + } + label_8: { + local2 = (local1 + 20); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local4 != 0) { + break label_8; + } + local2 = (local1 + 16); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local4 != 0) { + break label_8; + } + local6 = 0; + break label_6; + } + label_9: while (true) { + local5 = local2; + local6 = local4; + local2 = (local6 + 20); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + local2 = (local6 + 16); + local4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_2; + } + label_10: { + label_11: { + local4 = memory.readInt((int) local1 < 0 ? local1 : local1 + 28); + local2 = ((local4 << 2) + 657992); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) local2 < 0 ? local2 : local2 + 0), local1) != 0) { + break label_11; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local6); + if (local6 != 0) { + break label_10; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 657692) & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, local4))); + break label_2; + } + memory.writeI32((int) (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) < 0 ? (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) : (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local1, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) + 0, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) local7); + label_12: { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_12; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) local2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local6); + } + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_2; + } + memory.writeI32((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0, (int) local2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local6); + break label_2; + } + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(3, (local2 & 3)) != 0) { + break label_2; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) (local2 & -2)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) arg0); + memory.writeI32((int) (local1 + arg0) < 0 ? (local1 + arg0) : (local1 + arg0) + 0, (int) arg0); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) (arg0 | 1)); + return; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local1, local3) != 0) { + break label_1; + } + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local2 & 1)) != 0) { + break label_1; + } + label_13: { + label_14: { + if ((local2 & 2) != 0) { + break label_14; + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) 0 < 0 ? 0 : 0 + 657712), local3) != 0) { + break label_15; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657712, (int) local1); + arg0 = (memory.readInt((int) 0 < 0 ? 0 : 0 + 657700) + arg0); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657700, (int) arg0); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) (arg0 | 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) 0 < 0 ? 0 : 0 + 657708), local1) != 0) { + break label_1; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) 0); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657708, (int) 0); + return; + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) 0 < 0 ? 0 : 0 + 657708), local3) != 0) { + break label_16; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657708, (int) local1); + arg0 = (memory.readInt((int) 0 < 0 ? 0 : 0 + 657696) + arg0); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) arg0); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) (arg0 | 1)); + memory.writeI32((int) (local1 + arg0) < 0 ? (local1 + arg0) : (local1 + arg0) + 0, (int) arg0); + return; + } + arg0 = ((local2 & -8) + arg0); + label_17: { + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, 255) != 0) { + break label_18; + } + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + local5 = (local2 >>> 3); + local6 = ((local5 << 3) + 657728); + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4); + label_19: { + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local2) != 0) { + break label_19; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 657688) & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, local5))); + break label_17; + } + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local2); + break label_17; + } + local7 = memory.readInt((int) local3 < 0 ? local3 : local3 + 24); + label_20: { + label_21: { + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local6) != 0) { + break label_21; + } + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local2, memory.readInt((int) 0 < 0 ? 0 : 0 + 657704)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) local6); + break label_20; + } + label_22: { + local2 = (local3 + 20); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local4 != 0) { + break label_22; + } + local2 = (local3 + 16); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local4 != 0) { + break label_22; + } + local6 = 0; + break label_20; + } + label_23: while (true) { + local5 = local2; + local6 = local4; + local2 = (local6 + 20); + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + local2 = (local6 + 16); + local4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_17; + } + label_24: { + label_25: { + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 28); + local2 = ((local4 << 2) + 657992); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) local2 < 0 ? local2 : local2 + 0), local3) != 0) { + break label_25; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) local6); + if (local6 != 0) { + break label_24; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 657692) & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, local4))); + break label_17; + } + memory.writeI32((int) (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) < 0 ? (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) : (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) + 0, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_17; + } + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) local7); + label_26: { + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_26; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) local2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local6); + } + local2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_17; + } + memory.writeI32((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0, (int) local2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 24, (int) local6); + } + memory.writeI32((int) (local1 + arg0) < 0 ? (local1 + arg0) : (local1 + arg0) + 0, (int) arg0); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) (arg0 | 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) 0 < 0 ? 0 : 0 + 657708), local1) != 0) { + break label_13; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) arg0); + return; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) (local2 & -2)); + memory.writeI32((int) (local1 + arg0) < 0 ? (local1 + arg0) : (local1 + arg0) + 0, (int) arg0); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 4, (int) (arg0 | 1)); + } + label_27: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 255) != 0) { + break label_27; + } + local2 = ((arg0 & -8) + 657728); + label_28: { + label_29: { + local4 = memory.readInt((int) 0 < 0 ? 0 : 0 + 657688); + arg0 = (1 << (arg0 >>> 3)); + if ((local4 & arg0) != 0) { + break label_29; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (local4 | arg0)); + arg0 = local2; + break label_28; + } + arg0 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) local1); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local2); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) arg0); + return; + } + local2 = 31; + label_30: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 16777215) != 0) { + break label_30; + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ((arg0 >>> 8)); + local2 = ((((arg0 >>> (38 - local2)) & 1) - (local2 << 1)) + 62); + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 28, (int) local2); + memory.writeLong((int) local1 < 0 ? local1 : local1 + 16, (long) 0L); + local4 = ((local2 << 2) + 657992); + label_31: { + label_32: { + local6 = memory.readInt((int) 0 < 0 ? 0 : 0 + 657692); + local3 = (1 << local2); + if ((local6 & local3) != 0) { + break label_32; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local1); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (local6 | local3)); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 24, (int) local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) local1); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local1); + break label_31; + } + local2 = (arg0 << (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(31, local2) != 0 ? 0 : (25 - (local2 >>> 1)))); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + label_33: { + label_34: while (true) { + local4 = local6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, (memory.readInt((int) local4 < 0 ? local4 : local4 + 4) & -8)) != 0) { + break label_33; + } + local6 = (local2 >>> 29); + local2 = (local2 << 1); + local3 = ((local4 + (local6 & 4)) + 16); + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_34; + } + break; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local1); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 24, (int) local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local1); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) local1); + break label_31; + } + arg0 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) local1); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 24, (int) 0); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 12, (int) local4); + memory.writeI32((int) local1 < 0 ? local1 : local1 + 8, (int) arg0); + } + local1 = (memory.readInt((int) 0 < 0 ? 0 : 0 + 657720) + -1); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657720, (int) (local1 != 0 ? local1 : -1)); + } + return; + } + + public static long[] call_1785(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1785(arg0, memory, instance); + return null; + } + + public static int func_1786(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long local3 = 0L; + label_1: { + label_2: { + if (arg0 != 0) { + break label_2; + } + local2 = 0; + break label_1; + } + local3 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg0) * com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg1)); + local2 = (int) local3; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((arg1 | arg0), 65536) != 0) { + break label_1; + } + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (int) (local3 >>> 32L)) != 0 ? -1 : local2); + } + label_3: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local2); + long[] callResult_0 = instance.getMachine().call(1783, callArgs_0); + arg0 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (arg0 + -4) < 0 ? (arg0 + -4) : (arg0 + -4) + 0) & 0xFF) & 3)) != 0) { + break label_3; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1892, callArgs_1); + } + return arg0; + } + + public static long[] call_1786(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1786(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1787(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local2 = (arg0 + arg1); + label_1: { + label_2: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if ((local3 & 1) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local3 & 3)) != 0) { + break label_1; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + arg1 = (local3 + arg1); + label_3: { + label_4: { + arg0 = (arg0 - local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) 0 < 0 ? 0 : 0 + 657708), arg0) != 0) { + break label_4; + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 255) != 0) { + break label_5; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + local5 = (local3 >>> 3); + local6 = ((local5 << 3) + 657728); + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_3; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 657688) & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, local5))); + break label_2; + } + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24); + label_6: { + label_7: { + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, local6) != 0) { + break label_7; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, memory.readInt((int) 0 < 0 ? 0 : 0 + 657704)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local6); + break label_6; + } + label_8: { + local3 = (arg0 + 20); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (local4 != 0) { + break label_8; + } + local3 = (arg0 + 16); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (local4 != 0) { + break label_8; + } + local6 = 0; + break label_6; + } + label_9: while (true) { + local5 = local3; + local6 = local4; + local3 = (local6 + 20); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + local3 = (local6 + 16); + local4 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_2; + } + label_10: { + label_11: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28); + local3 = ((local4 << 2) + 657992); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) local3 < 0 ? local3 : local3 + 0), arg0) != 0) { + break label_11; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local6); + if (local6 != 0) { + break label_10; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 657692) & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, local4))); + break label_2; + } + memory.writeI32((int) (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) < 0 ? (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) : (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg0, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) + 0, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) local7); + label_12: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_12; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) local3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local6); + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_2; + } + memory.writeI32((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0, (int) local3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local6); + break label_2; + } + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(3, (local3 & 3)) != 0) { + break label_2; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (local3 & -2)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) arg1); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg1 | 1)); + return; + } + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local3); + } + label_13: { + label_14: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 4); + if ((local3 & 2) != 0) { + break label_14; + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) 0 < 0 ? 0 : 0 + 657712), local2) != 0) { + break label_15; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657712, (int) arg0); + arg1 = (memory.readInt((int) 0 < 0 ? 0 : 0 + 657700) + arg1); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657700, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg1 | 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) 0 < 0 ? 0 : 0 + 657708), arg0) != 0) { + break label_1; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) 0); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657708, (int) 0); + return; + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) 0 < 0 ? 0 : 0 + 657708), local2) != 0) { + break label_16; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657708, (int) arg0); + arg1 = (memory.readInt((int) 0 < 0 ? 0 : 0 + 657696) + arg1); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg1 | 1)); + memory.writeI32((int) (arg0 + arg1) < 0 ? (arg0 + arg1) : (arg0 + arg1) + 0, (int) arg1); + return; + } + arg1 = ((local3 & -8) + arg1); + label_17: { + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local3, 255) != 0) { + break label_18; + } + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + local5 = (local3 >>> 3); + local6 = ((local5 << 3) + 657728); + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local4); + label_19: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local3) != 0) { + break label_19; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 657688) & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, local5))); + break label_17; + } + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local6, local3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) local3); + break label_17; + } + local7 = memory.readInt((int) local2 < 0 ? local2 : local2 + 24); + label_20: { + label_21: { + local6 = memory.readInt((int) local2 < 0 ? local2 : local2 + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local6) != 0) { + break label_21; + } + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 8); + com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, memory.readInt((int) 0 < 0 ? 0 : 0 + 657704)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 8, (int) local3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local6); + break label_20; + } + label_22: { + local4 = (local2 + 20); + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (local3 != 0) { + break label_22; + } + local4 = (local2 + 16); + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (local3 != 0) { + break label_22; + } + local6 = 0; + break label_20; + } + label_23: while (true) { + local5 = local4; + local6 = local3; + local4 = (local6 + 20); + local3 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + local4 = (local6 + 16); + local3 = memory.readInt((int) local6 < 0 ? local6 : local6 + 16); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) 0); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local7) != 0) { + break label_17; + } + label_24: { + label_25: { + local4 = memory.readInt((int) local2 < 0 ? local2 : local2 + 28); + local3 = ((local4 << 2) + 657992); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) local3 < 0 ? local3 : local3 + 0), local2) != 0) { + break label_25; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local6); + if (local6 != 0) { + break label_24; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 657692) & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, local4))); + break label_17; + } + memory.writeI32((int) (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) < 0 ? (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) : (local7 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, memory.readInt((int) local7 < 0 ? local7 : local7 + 16)) != 0 ? 16 : 20)) + 0, (int) local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_17; + } + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 24, (int) local7); + label_26: { + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_26; + } + memory.writeI32((int) local6 < 0 ? local6 : local6 + 16, (int) local3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local6); + } + local3 = memory.readInt((int) local2 < 0 ? local2 : local2 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + memory.writeI32((int) (local6 + 20) < 0 ? (local6 + 20) : (local6 + 20) + 0, (int) local3); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) local6); + } + memory.writeI32((int) (arg0 + arg1) < 0 ? (arg0 + arg1) : (arg0 + arg1) + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg1 | 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) 0 < 0 ? 0 : 0 + 657708), arg0) != 0) { + break label_13; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) arg1); + return; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (local3 & -2)); + memory.writeI32((int) (arg0 + arg1) < 0 ? (arg0 + arg1) : (arg0 + arg1) + 0, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (arg1 | 1)); + } + label_27: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 255) != 0) { + break label_27; + } + local3 = ((arg1 & -8) + 657728); + label_28: { + label_29: { + local4 = memory.readInt((int) 0 < 0 ? 0 : 0 + 657688); + arg1 = (1 << (arg1 >>> 3)); + if ((local4 & arg1) != 0) { + break label_29; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (local4 | arg1)); + arg1 = local3; + break label_28; + } + arg1 = memory.readInt((int) local3 < 0 ? local3 : local3 + 8); + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 12, (int) arg0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + return; + } + local3 = 31; + label_30: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 16777215) != 0) { + break label_30; + } + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ((arg1 >>> 8)); + local3 = ((((arg1 >>> (38 - local3)) & 1) - (local3 << 1)) + 62); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 28, (int) local3); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 16, (long) 0L); + local4 = ((local3 << 2) + 657992); + label_31: { + local6 = memory.readInt((int) 0 < 0 ? 0 : 0 + 657692); + local2 = (1 << local3); + if ((local6 & local2) != 0) { + break label_31; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) arg0); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (local6 | local2)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg0); + return; + } + local3 = (arg1 << (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(31, local3) != 0 ? 0 : (25 - (local3 >>> 1)))); + local6 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + label_32: { + label_33: while (true) { + local4 = local6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, (memory.readInt((int) local4 < 0 ? local4 : local4 + 4) & -8)) != 0) { + break label_32; + } + local6 = (local3 >>> 29); + local3 = (local3 << 1); + local2 = ((local4 + (local6 & 4)) + 16); + local6 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (local6 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_33; + } + break; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) arg0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) arg0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg0); + return; + } + arg1 = memory.readInt((int) local4 < 0 ? local4 : local4 + 8); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 12, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 8, (int) arg0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 12, (int) local4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) arg1); + } + return; + } + + public static long[] call_1787(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + Wat2WasmMachine.func_1787(arg0, arg1, memory, instance); + return null; + } + + public static int func_1788(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + label_1: { + label_2: { + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 16) != 0 ? arg0 : 16); + if ((local2 & (local2 + -1)) != 0) { + break label_2; + } + arg0 = local2; + break label_1; + } + local3 = 32; + label_3: while (true) { + arg0 = local3; + local3 = (arg0 << 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg0, local2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((-64 - arg0), arg1) != 0) { + break label_4; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 48); + return 0; + } + label_5: { + arg1 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 11) != 0 ? 16 : ((arg1 + 19) & -16)); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) ((arg0 + arg1) + 12)); + long[] callResult_0 = instance.getMachine().call(1783, callArgs_0); + local3 = ((int) callResult_0[0]); + if (local3 != 0) { + break label_5; + } + return 0; + } + local2 = (local3 + -8); + label_6: { + label_7: { + if (((arg0 + -1) & local3) != 0) { + break label_7; + } + arg0 = local2; + break label_6; + } + local4 = (local3 + -4); + local5 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local3 = ((((local3 + arg0) + -1) & (0 - arg0)) + -8); + arg0 = (local3 + (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((local3 - local2), 15) != 0 ? 0 : arg0)); + local3 = (arg0 - local2); + local6 = ((local5 & -8) - local3); + label_8: { + if ((local5 & 3) != 0) { + break label_8; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (memory.readInt((int) local2 < 0 ? local2 : local2 + 0) + local3)); + break label_6; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) ((local6 | (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) & 1)) | 2)); + local6 = (arg0 + local6); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 4) | 1)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) ((local3 | (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) & 1)) | 2)); + local6 = (local2 + local3); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 4, (int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 4) | 1)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) local2); + instance.getMachine().call(1787, callArgs_1); + } + label_9: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local3 & 3)) != 0) { + break label_9; + } + local2 = (local3 & -8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local2, (arg1 + 16)) != 0) { + break label_9; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) ((arg1 | (local3 & 1)) | 2)); + local3 = (arg0 + arg1); + arg1 = (local2 - arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) (arg1 | 3)); + local2 = (arg0 + local2); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) (memory.readInt((int) local2 < 0 ? local2 : local2 + 4) | 1)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) local3); + instance.getMachine().call(1787, callArgs_2); + } + return (arg0 + 8); + } + + public static long[] call_1788(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1788(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1789(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 16) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1783, callArgs_0); + return ((int) callResult_0[0]); + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1788, callArgs_1); + return ((int) callResult_1[0]); + } + + public static long[] call_1789(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1789(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1790(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(1806, callArgs_0); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1790(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1790(arg0, memory, instance); + return null; + } + + public static int func_1791(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + int local1 = 0; + int local2 = 0; + local0 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local0)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local0 + 12)); + callArgs_0[0] = ((long) (local0 + 8)); + long[] callResult_0 = instance.getMachine().call(1793, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_5; + } + local1 = (memory.readInt((int) local0 < 0 ? local0 : local0 + 8) + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_4; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) local0 < 0 ? local0 : local0 + 12)); + long[] callResult_1 = instance.getMachine().call(1782, callArgs_1); + local2 = ((int) callResult_1[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_3; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 4); + callArgs_2[0] = ((long) local1); + long[] callResult_2 = instance.getMachine().call(1786, callArgs_2); + local1 = ((int) callResult_2[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_2; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local2); + callArgs_3[0] = ((long) local1); + long[] callResult_3 = instance.getMachine().call(1792, callArgs_3); + if (((int) callResult_3[0]) != 0) { + break label_1; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) local1); + callArgs_4[0] = ((long) memory.readInt((int) local0 < 0 ? local0 : local0 + 8)); + long[] callResult_4 = instance.getMachine().call(33, callArgs_4); + local1 = ((int) callResult_4[0]); + instance.global(0).setValue(((long) (local0 + 16))); + return local1; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 71); + instance.getMachine().call(1790, callArgs_5); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) 70); + instance.getMachine().call(1790, callArgs_6); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) 70); + instance.getMachine().call(1790, callArgs_7); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) local2); + instance.getMachine().call(1784, callArgs_8); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) 70); + instance.getMachine().call(1790, callArgs_9); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) local2); + instance.getMachine().call(1784, callArgs_10); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) local1); + instance.getMachine().call(1784, callArgs_11); + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) 71); + instance.getMachine().call(1790, callArgs_12); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1791(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int result = Wat2WasmMachine.func_1791(memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1792(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(0, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1792(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1792(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1793(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1793(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1793(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1794(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(2, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1794(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1794(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1795(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(3, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1795(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1795(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1796(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(4, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1796(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1796(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1797(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(5, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1797(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1797(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1798(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(6, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1798(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1798(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1799(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(7, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1799(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1799(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1800(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(8, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1800(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1800(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1801(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(9, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1801(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1801(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1802(int arg0, long arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = arg1; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(10, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1802(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1802(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1803(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(11, callArgs_0); + return (((int) callResult_0[0]) & 65535); + } + + public static long[] call_1803(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1803(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1804(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg2); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) arg3); + callArgs_1[3] = ((long) ((int) callResult_0[0])); + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(12, callArgs_1); + return (((int) callResult_1[0]) & 65535); + } + + public static long[] call_1804(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1804(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1805(int arg0, int arg1, int arg2, int arg3, long arg4, long arg5, int arg6, int arg7, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg2); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + long[] callArgs_1 = new long[9]; + callArgs_1[8] = ((long) arg7); + callArgs_1[7] = ((long) arg6); + callArgs_1[6] = arg5; + callArgs_1[5] = arg4; + callArgs_1[4] = ((long) arg3); + callArgs_1[3] = ((long) ((int) callResult_0[0])); + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(13, callArgs_1); + return (((int) callResult_1[0]) & 65535); + } + + public static long[] call_1805(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + long arg4 = args[4]; + long arg5 = args[5]; + int arg6 = ((int) args[6]); + int arg7 = ((int) args[7]); + int result = Wat2WasmMachine.func_1805(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1806(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + instance.getMachine().call(14, callArgs_0); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1806(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1806(arg0, memory, instance); + return null; + } + + public static void func_1807(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1807(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_1807(memory, instance); + return null; + } + + public static int func_1808(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + local1 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local1)); + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local1 + 8)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1797, callArgs_0); + arg0 = ((int) callResult_0[0]); + if (arg0 != 0) { + break label_2; + } + arg0 = 59; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(2, ((int) memory.read((int) local1 < 0 ? local1 : local1 + 8) & 0xFF)) != 0) { + break label_2; + } + if ((((int) memory.read((int) local1 < 0 ? local1 : local1 + 16) & 0xFF) & 36) != 0) { + break label_2; + } + local2 = 1; + break label_1; + } + local2 = 0; + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) arg0); + } + instance.global(0).setValue(((long) (local1 + 32))); + return local2; + } + + public static long[] call_1808(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1808(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1809(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + long local5 = 0L; + long local6 = 0L; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + label_4: { + local4 = (((arg2 & 503316480) + -33554432) >>> 25); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, 9) != 0) { + break label_4; + } + local4 = (1 << local4); + if ((local4 & 642) != 0) { + break label_3; + } + local5 = -4211012L; + if ((local4 & 9) != 0) { + break label_2; + } + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 28); + local4 = -1; + break label_1; + } + local5 = ((arg2 & 67108864) != 0 ? -4194626L : -4211012L); + local5 = ((arg2 & 268435456) != 0 ? (local5 | 4194625L) : local5); + } + label_5: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1797, callArgs_0); + local4 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_5; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) local4); + local4 = -1; + break label_1; + } + local4 = -1; + label_6: { + local6 = memory.readLong((int) local3 < 0 ? local3 : local3 + 24); + long[] callArgs_1 = new long[8]; + callArgs_1[7] = ((long) (local3 + 4)); + callArgs_1[6] = ((long) (arg2 & 4095)); + callArgs_1[5] = local6; + callArgs_1[4] = (local6 & local5); + callArgs_1[3] = ((long) ((arg2 >>> 12) & 4095)); + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) (((arg2 ^ -1) >>> 24) & 1)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1805, callArgs_1); + arg2 = ((int) callResult_1[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_6; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) arg2); + break label_1; + } + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + } + instance.global(0).setValue(((long) (local3 + 32))); + return local4; + } + + public static long[] call_1809(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1809(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1810(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + long local6 = 0L; + long local7 = 0L; + long local8 = 0L; + long local9 = 0L; + long local10 = 0L; + long local11 = 0L; + local4 = (((int) instance.global(0).getValue()) - 96); + instance.global(0).setValue(((long) local4)); + local5 = -1; + label_1: { + label_2: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) local4); + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) ((arg3 ^ -1) & 1)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1804, callArgs_0); + arg3 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg3) != 0) { + break label_2; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) arg3); + break label_1; + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 24, (long) 0L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 16, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 24)); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 8, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 8)); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 0)); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 64, (long) 0L); + local5 = 0; + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 56, (int) 0); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 48, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 32)); + memory.writeLong((int) (local4 + 80) < 0 ? (local4 + 80) : (local4 + 80) + 0, (long) 0L); + memory.writeLong((int) (local4 + 88) < 0 ? (local4 + 88) : (local4 + 88) + 0, (long) 0L); + memory.writeLong((int) (arg2 + 32) < 0 ? (arg2 + 32) : (arg2 + 32) + 0, (long) 0L); + memory.writeLong((int) (arg2 + 40) < 0 ? (arg2 + 40) : (arg2 + 40) + 0, (long) 0L); + local6 = memory.readLong((int) local4 < 0 ? local4 : local4 + 56); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I64_DIV_U(local6, 1000000000L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 104, (long) local7); + local8 = memory.readLong((int) local4 < 0 ? local4 : local4 + 48); + local9 = com.dylibso.chicory.runtime.OpcodeImpl.I64_DIV_U(local8, 1000000000L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 88, (long) local9); + local10 = memory.readLong((int) local4 < 0 ? local4 : local4 + 40); + local11 = com.dylibso.chicory.runtime.OpcodeImpl.I64_DIV_U(local10, 1000000000L); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 72, (long) local11); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 112, (int) (local6 - (local7 * 1000000000L))); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 96, (int) (local8 - (local9 * 1000000000L))); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 80, (int) (local10 - (local11 * 1000000000L))); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 72, (long) 0L); + memory.writeI32((int) (arg2 + 140) < 0 ? (arg2 + 140) : (arg2 + 140) + 0, (int) memory.readInt((int) ((local4 + 68) + 24) < 0 ? ((local4 + 68) + 24) : ((local4 + 68) + 24) + 0)); + memory.writeLong((int) (arg2 + 132) < 0 ? (arg2 + 132) : (arg2 + 132) + 0, (long) memory.readLong((int) (local4 + 84) < 0 ? (local4 + 84) : (local4 + 84) + 0)); + memory.writeLong((int) (arg2 + 124) < 0 ? (arg2 + 124) : (arg2 + 124) + 0, (long) memory.readLong((int) (local4 + 76) < 0 ? (local4 + 76) : (local4 + 76) + 0)); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 116, (long) memory.readLong((int) local4 < 0 ? local4 : local4 + 68)); + arg3 = (((int) memory.read((int) local4 < 0 ? local4 : local4 + 16) & 0xFF) + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((arg3 & 255), 6) != 0) { + break label_1; + } + memory.writeI32((int) (arg2 + 24) < 0 ? (arg2 + 24) : (arg2 + 24) + 0, (int) memory.readInt((int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg3) << 2) + 59884) < 0 ? ((com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg3) << 2) + 59884) : ((com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(arg3) << 2) + 59884) + 0)); + } + instance.global(0).setValue(((long) (local4 + 96))); + return local5; + } + + public static long[] call_1810(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1810(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1811(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1796, callArgs_0); + arg0 = ((int) callResult_0[0]); + if (arg0 != 0) { + break label_1; + } + return 0; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) arg0); + return -1; + } + + public static long[] call_1811(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1811(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1812(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(0) != 0) { + break label_2; + } + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 1); + callArgs_0[3] = ((long) 658192); + callArgs_0[2] = ((long) 658188); + callArgs_0[1] = ((long) (local2 + 12)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(17, callArgs_0); + local3 = ((int) callResult_0[0]); + break label_1; + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) 658192 < 0 ? 658192 : 658192 + 0)); + callArgs_1[2] = ((long) 658188); + callArgs_1[1] = ((long) (local2 + 12)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1815, callArgs_1); + local3 = ((int) callResult_1[0]); + } + arg0 = -1; + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local3) != 0) { + break label_4; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 44); + break label_3; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) memory.readInt((int) 658188 < 0 ? 658188 : 658188 + 0)); + callArgs_2[0] = ((long) local3); + long[] callResult_2 = instance.getMachine().call(1809, callArgs_2); + arg0 = ((int) callResult_2[0]); + } + instance.global(0).setValue(((long) (local2 + 16))); + return arg0; + } + + public static long[] call_1812(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1812(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1813(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(0) != 0) { + break label_2; + } + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 1); + callArgs_0[3] = ((long) 658192); + callArgs_0[2] = ((long) 658188); + callArgs_0[1] = ((long) (local2 + 12)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(17, callArgs_0); + local3 = ((int) callResult_0[0]); + break label_1; + } + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) memory.readInt((int) 658192 < 0 ? 658192 : 658192 + 0)); + callArgs_1[2] = ((long) 658188); + callArgs_1[1] = ((long) (local2 + 12)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1815, callArgs_1); + local3 = ((int) callResult_1[0]); + } + arg0 = -1; + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local3) != 0) { + break label_4; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 44); + break label_3; + } + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) 0); + callArgs_2[2] = ((long) arg1); + callArgs_2[1] = ((long) memory.readInt((int) 658188 < 0 ? 658188 : 658188 + 0)); + callArgs_2[0] = ((long) local3); + long[] callResult_2 = instance.getMachine().call(1810, callArgs_2); + arg0 = ((int) callResult_2[0]); + } + instance.global(0).setValue(((long) (local2 + 16))); + return arg0; + } + + public static long[] call_1813(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1813(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1814(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + label_2: { + switch((arg0 + 2)) { + case 0: + { + break label_1; + } + case 1: + { + break label_1; + } + default: + { + break label_2; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + label_3: { + local2 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658196); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) 0 < 0 ? 0 : 0 + 658204), local2) != 0) { + break label_3; + } + local3 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658200); + label_4: { + local4 = (local2 != 0 ? (local2 << 1) : 4); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) 8); + long[] callResult_0 = instance.getMachine().call(1786, callArgs_0); + local5 = ((int) callResult_0[0]); + if (local5 != 0) { + break label_4; + } + return -1; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (local2 << 3)); + callArgs_1[1] = ((long) local3); + callArgs_1[0] = ((long) local5); + long[] callResult_1 = instance.getMachine().call(1890, callArgs_1); + local5 = ((int) callResult_1[0]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658204, (int) local4); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658200, (int) local5); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) local3); + instance.getMachine().call(1784, callArgs_2); + } + label_5: { + label_6: while (true) { + label_7: { + label_8: { + local3 = arg1; + switch((((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF) + -46)) { + case 0: + { + break label_7; + } + case 1: + { + break label_8; + } + default: + { + break label_5; + } + } + } + arg1 = (local3 + 1); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + arg1 = (local3 + 1); + local4 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 1) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(47, local4) != 0) { + break label_5; + } + arg1 = (local3 + 2); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + } + label_9: { + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local3); + long[] callResult_3 = instance.getMachine().call(1896, callArgs_3); + local3 = ((int) callResult_3[0]); + if (local3 != 0) { + break label_9; + } + return -1; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658196, (int) (local2 + 1)); + arg1 = (memory.readInt((int) 0 < 0 ? 0 : 0 + 658200) + (local2 << 3)); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 4, (int) arg0); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local3); + return 0; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1814(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1814(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1815(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg3); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(0) != 0) { + break label_2; + } + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) 0); + callArgs_0[3] = ((long) (local4 + 12)); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(17, callArgs_0); + arg3 = ((int) callResult_0[0]); + break label_1; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1816, callArgs_1); + arg3 = ((int) callResult_1[0]); + } + instance.global(0).setValue(((long) (local4 + 16))); + return arg3; + } + + public static long[] call_1815(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1815(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1816(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + int local10 = 0; + int local11 = 0; + int local12 = 0; + local3 = (arg0 + -1); + label_1: while (true) { + local3 = (local3 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(47, ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + break; + } + local4 = 0; + label_2: { + label_3: { + local5 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658196); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + local6 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658200); + local7 = -1; + label_4: while (true) { + local5 = (local5 + -1); + local8 = (local6 + (local5 << 3)); + local9 = memory.readInt((int) local8 < 0 ? local8 : local8 + 0); + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) local9); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local10 = ((int) callResult_0[0]); + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, local7) != 0) { + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(local10, local4) != 0) { + break label_5; + } + } + label_7: { + label_8: { + if (local10 != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(47, (((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF) & 255)) != 0) { + break label_7; + } + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local10); + callArgs_1[1] = ((long) local9); + callArgs_1[0] = ((long) local3); + long[] callResult_1 = instance.getMachine().call(1889, callArgs_1); + if (((int) callResult_1[0]) != 0) { + break label_5; + } + local11 = (local9 + -1); + local12 = local10; + label_9: { + label_10: while (true) { + arg0 = local12; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_9; + } + local12 = (arg0 + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(47, ((int) memory.read((int) (local11 + arg0) < 0 ? (local11 + arg0) : (local11 + arg0) + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + arg0 = ((int) memory.read((int) (local3 + arg0) < 0 ? (local3 + arg0) : (local3 + arg0) + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(47, arg0) != 0) { + break label_7; + } + if (arg0 != 0) { + break label_5; + } + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) local9); + local7 = memory.readInt((int) local8 < 0 ? local8 : local8 + 4); + local4 = local10; + } + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, local7) != 0) { + break label_2; + } + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 44); + return -1; + } + arg0 = ((local3 + local4) + -1); + label_11: while (true) { + arg0 = (arg0 + 1); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(47, local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (local3 != 0 ? arg0 : 29323)); + return local7; + } + + public static long[] call_1816(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1816(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1817(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + int local1 = 0; + int local2 = 0; + int local3 = 0; + local0 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local0)); + local1 = 3; + label_1: { + label_2: { + label_3: while (true) { + label_4: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local0 + 8)); + callArgs_0[0] = ((long) local1); + long[] callResult_0 = instance.getMachine().call(1799, callArgs_0); + local2 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, local2) != 0) { + break label_2; + } + instance.global(0).setValue(((long) (local0 + 16))); + return; + } + label_5: { + if (((int) memory.read((int) local0 < 0 ? local0 : local0 + 8) & 0xFF) != 0) { + break label_5; + } + local3 = memory.readInt((int) local0 < 0 ? local0 : local0 + 12); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) (local3 + 1)); + long[] callResult_1 = instance.getMachine().call(1782, callArgs_1); + local2 = ((int) callResult_1[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) local2); + callArgs_2[0] = ((long) local1); + long[] callResult_2 = instance.getMachine().call(1800, callArgs_2); + if (((int) callResult_2[0]) != 0) { + break label_2; + } + memory.writeByte((int) (local2 + memory.readInt((int) local0 < 0 ? local0 : local0 + 12)) < 0 ? (local2 + memory.readInt((int) local0 < 0 ? local0 : local0 + 12)) : (local2 + memory.readInt((int) local0 < 0 ? local0 : local0 + 12)) + 0, (byte) (0)); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) local2); + callArgs_3[0] = ((long) local1); + long[] callResult_3 = instance.getMachine().call(1814, callArgs_3); + if (((int) callResult_3[0]) != 0) { + break label_1; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) local2); + instance.getMachine().call(1784, callArgs_4); + } + local1 = (local1 + 1); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 71); + instance.getMachine().call(1790, callArgs_5); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) 70); + instance.getMachine().call(1790, callArgs_6); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1817(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_1817(memory, instance); + return null; + } + + public static int func_1818(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (arg0 != 0) { + break label_1; + } + return (memory.pages() << 16); + } + label_2: { + if ((arg0 & 65535) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg0, -1) != 0) { + break label_2; + } + label_3: { + arg0 = memory.grow((arg0 >>> 16)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, arg0) != 0) { + break label_3; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 48); + return -1; + } + return (arg0 << 16); + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1818(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1818(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1819(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((arg0 + -32), 95); + } + + public static long[] call_1819(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1819(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1820(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) 0 < 0 ? 0 : 0 + 621584)) != 0) { + break label_1; + } + instance.getMachine().call(1821, new long[0]); + } + return; + } + + public static long[] call_1820(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_1820(memory, instance); + return null; + } + + public static void func_1821(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + int local1 = 0; + int local2 = 0; + local0 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local0)); + label_1: { + label_2: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local0 + 8)); + callArgs_0[0] = ((long) (local0 + 12)); + long[] callResult_0 = instance.getMachine().call(1795, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_2; + } + label_3: { + local1 = memory.readInt((int) local0 < 0 ? local0 : local0 + 12); + if (local1 != 0) { + break label_3; + } + local1 = 658208; + break label_1; + } + label_4: { + label_5: { + local1 = (local1 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_5; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) local0 < 0 ? local0 : local0 + 8)); + long[] callResult_1 = instance.getMachine().call(1782, callArgs_1); + local2 = ((int) callResult_1[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_5; + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) 4); + callArgs_2[0] = ((long) local1); + long[] callResult_2 = instance.getMachine().call(1786, callArgs_2); + local1 = ((int) callResult_2[0]); + if (local1 != 0) { + break label_4; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) local2); + instance.getMachine().call(1784, callArgs_3); + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 70); + instance.getMachine().call(1790, callArgs_4); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) local2); + callArgs_5[0] = ((long) local1); + long[] callResult_5 = instance.getMachine().call(1794, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_5[0])) != 0) { + break label_1; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) local2); + instance.getMachine().call(1784, callArgs_6); + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) local1); + instance.getMachine().call(1784, callArgs_7); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) 71); + instance.getMachine().call(1790, callArgs_8); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621584, (int) local1); + instance.global(0).setValue(((long) (local0 + 16))); + return; + } + + public static long[] call_1821(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_1821(memory, instance); + return null; + } + + public static int func_1822(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + instance.getMachine().call(1820, new long[0]); + label_1: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 61); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1894, callArgs_1); + local1 = ((int) callResult_1[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg0, local1) != 0) { + break label_1; + } + return 0; + } + local2 = 0; + label_2: { + local3 = (local1 - arg0); + if (((int) memory.read((int) (arg0 + local3) < 0 ? (arg0 + local3) : (arg0 + local3) + 0) & 0xFF) != 0) { + break label_2; + } + local4 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621584); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + local1 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local1) != 0) { + break label_2; + } + local4 = (local4 + 4); + label_3: { + label_4: while (true) { + label_5: { + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local3); + callArgs_2[1] = ((long) local1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1898, callArgs_2); + if (((int) callResult_2[0]) != 0) { + break label_5; + } + local1 = (local1 + local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(61, ((int) memory.read((int) local1 < 0 ? local1 : local1 + 0) & 0xFF)) != 0) { + break label_3; + } + } + local1 = memory.readInt((int) local4 < 0 ? local4 : local4 + 0); + local4 = (local4 + 4); + if (local1 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break label_2; + } + } + local2 = (local1 + 1); + } + return local2; + } + + public static long[] call_1822(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1822(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1823(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + label_1: { + local1 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658504); + if (local1 != 0) { + break label_1; + } + local1 = 658480; + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658504, (int) 658480); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) memory.readInt((int) local1 < 0 ? local1 : local1 + 20)); + callArgs_0[0] = ((long) (((int) memory.readShort((int) (((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 76) != 0 ? 0 : arg0) << 1) + 61472) < 0 ? (((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 76) != 0 ? 0 : arg0) << 1) + 61472) : (((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg0, 76) != 0 ? 0 : arg0) << 1) + 61472) + 0) & 0xFFFF) + 59912)); + long[] callResult_0 = instance.getMachine().call(1829, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_1823(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1823(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1824(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + int local1 = 0; + int local2 = 0; + label_1: { + local0 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658212); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local0) != 0) { + break label_1; + } + local1 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658216); + label_2: while (true) { + local2 = (local1 + -1); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658216, (int) local2); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local1, 1) != 0) { + break label_3; + } + label_4: while (true) { + local2 = (memory.readInt((int) 0 < 0 ? 0 : 0 + 658212) + (local2 << 2)); + int ciTableIdx_0 = (int) (memory.readInt((int) (local2 + 4) < 0 ? (local2 + 4) : (local2 + 4) + 0)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) (local2 + 132) < 0 ? (local2 + 132) : (local2 + 132) + 0)); + ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local0 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658216); + local2 = (local0 + -1); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658216, (int) local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local0, 0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + local0 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658212); + } + local1 = 32; + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658216, (int) 32); + local0 = memory.readInt((int) local0 < 0 ? local0 : local0 + 0); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658212, (int) local0); + if (local0 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + return; + } + + public static long[] call_1824(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_1824(memory, instance); + return null; + } + + public static int func_1825(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + label_1: { + local3 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658212); + if (local3 != 0) { + break label_1; + } + local3 = 658220; + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658212, (int) 658220); + } + label_2: { + local4 = memory.readInt((int) 0 < 0 ? 0 : 0 + 658216); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(32, local4) != 0) { + break label_2; + } + label_3: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 1); + callArgs_0[0] = ((long) 260); + long[] callResult_0 = instance.getMachine().call(1786, callArgs_0); + local3 = ((int) callResult_0[0]); + if (local3 != 0) { + break label_3; + } + return -1; + } + local4 = 0; + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 658212)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658212, (int) local3); + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658216, (int) (local4 + 1)); + local3 = (local3 + (local4 << 2)); + memory.writeI32((int) (local3 + 132) < 0 ? (local3 + 132) : (local3 + 132) + 0, (int) arg1); + memory.writeI32((int) (local3 + 4) < 0 ? (local3 + 4) : (local3 + 4) + 0, (int) arg0); + return 0; + } + + public static long[] call_1825(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1825(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1826(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(1824, new long[0]); + instance.getMachine().call(1849, new long[0]); + return; + } + + public static long[] call_1826(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_1826(memory, instance); + return null; + } + + public static void func_1827(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + instance.getMachine().call(1824, new long[0]); + instance.getMachine().call(1849, new long[0]); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1790, callArgs_2); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1827(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1827(arg0, memory, instance); + return null; + } + + public static int func_1828(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return arg0; + } + + public static long[] call_1828(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1828(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1829(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1828, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_1829(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1829(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1830(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return; + } + + public static long[] call_1830(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1830(arg0, memory, instance); + return null; + } + + public static int func_1831(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1833, callArgs_0); + local1 = ((int) callResult_0[0]); + int ciTableIdx_1 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 12)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local2 = ((int) callResult_1[0]); + label_1: { + if ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 1) != 0) { + break label_1; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + instance.getMachine().call(1830, callArgs_2); + long[] callResult_3 = instance.getMachine().call(1857, new long[0]); + local3 = ((int) callResult_3[0]); + label_2: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 52, (int) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 52)); + } + label_3: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 48, (int) local4); + } + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg0, memory.readInt((int) local3 < 0 ? local3 : local3 + 0)) != 0) { + break label_4; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local5); + } + instance.getMachine().call(1858, new long[0]); + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 80)); + instance.getMachine().call(1784, callArgs_5); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(1784, callArgs_6); + } + return (local2 | local1); + } + + public static long[] call_1831(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1831(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1832(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return ((memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) >>> 5) & 1); + } + + public static long[] call_1832(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1832(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1833(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + label_1: { + if (arg0 != 0) { + break label_1; + } + local1 = 0; + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) 0 < 0 ? 0 : 0 + 621944)) != 0) { + break label_2; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 621944)); + long[] callResult_0 = instance.getMachine().call(1833, callArgs_0); + local1 = ((int) callResult_0[0]); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) 0 < 0 ? 0 : 0 + 621704)) != 0) { + break label_3; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 621704)); + long[] callResult_1 = instance.getMachine().call(1833, callArgs_1); + local1 = (((int) callResult_1[0]) | local1); + } + label_4: { + long[] callResult_2 = instance.getMachine().call(1857, new long[0]); + arg0 = memory.readInt((int) ((int) callResult_2[0]) < 0 ? ((int) callResult_2[0]) : ((int) callResult_2[0]) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_4; + } + label_5: while (true) { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_6; + } + int ciTableIdx_3 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + label_7: { + label_8: { + if (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) != 0) { + break label_8; + } + local2 = -1; + break label_7; + } + label_9: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local2) != 0) { + break label_9; + } + int ciTableIdx_4 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(20))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 1); + callArgs_4[1] = (long) (local2 - local3); + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + local2 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 16, (long) 0L); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + } + local1 = (local2 | local1); + } + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 52); + if (arg0 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + instance.getMachine().call(1858, new long[0]); + return local1; + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_10; + } + int ciTableIdx_6 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 0); + callArgs_6[1] = ((long) 0); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + if (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) != 0) { + break label_10; + } + return -1; + } + label_11: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local1) != 0) { + break label_11; + } + int ciTableIdx_7 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(20))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 1); + callArgs_7[1] = (long) (local1 - local2); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 16, (long) 0L); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + return 0; + } + + public static long[] call_1833(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1833(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1834(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + arg0 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg0, -1) != 0) { + break label_1; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 8); + arg0 = -1; + } + return arg0; + } + + public static long[] call_1834(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1834(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1835(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + local1 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(114, local1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 43); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1893, callArgs_0); + local3 = (((int) callResult_0[0]) != 0 ? 335544320 : (local2 != 0 ? 67108864 : 268435456)); + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 120); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1893, callArgs_1); + arg0 = (((int) callResult_1[0]) != 0 ? (local3 | 16384) : local3); + arg0 = (local2 != 0 ? arg0 : (arg0 | 4096)); + return ((com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(119, local1) != 0 ? (arg0 | 32768) : arg0) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(97, local1)); + } + + public static long[] call_1835(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1835(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1836(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + long local4 = 0L; + long local5 = 0L; + local3 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + switch((arg1 + -1)) { + case 0: + { + break label_1; + } + case 1: + { + break label_6; + } + case 2: + { + break label_5; + } + case 3: + { + break label_4; + } + default: + { + break label_3; + } + } + } + arg1 = 0; + break label_1; + } + label_7: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1797, callArgs_0); + arg1 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_7; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) arg1); + break label_2; + } + local4 = memory.readLong((int) local3 < 0 ? local3 : local3 + 16); + local5 = (local4 & 64L); + arg1 = ((int) memory.readShort((int) local3 < 0 ? local3 : local3 + 10) & 0xFFFF); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ((local4 & 16386L)) != 0) { + break label_8; + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(local5) != 0) { + break label_9; + } + arg1 = (arg1 | 335544320); + break label_1; + } + arg1 = (arg1 | 67108864); + break label_1; + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(local5) != 0) { + break label_10; + } + arg1 = (arg1 | 268435456); + break label_1; + } + arg1 = (arg1 | 134217728); + break label_1; + } + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) (arg2 + 4)); + label_11: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) & 4095)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1798, callArgs_1); + arg1 = ((int) callResult_1[0]); + if (arg1 != 0) { + break label_11; + } + arg1 = 0; + break label_1; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) arg1); + break label_2; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 28); + } + arg1 = -1; + } + instance.global(0).setValue(((long) (local3 + 32))); + return arg1; + } + + public static long[] call_1836(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1836(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static long func_1837(int arg0, long arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + label_1: { + label_2: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local3 + 8)); + callArgs_0[2] = ((long) (arg2 & 255)); + callArgs_0[1] = arg1; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1802, callArgs_0); + arg2 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_2; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(76, arg2) != 0 ? 70 : arg2)); + arg1 = -1L; + break label_1; + } + arg1 = memory.readLong((int) local3 < 0 ? local3 : local3 + 8); + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg1; + } + + public static long[] call_1837(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int arg2 = ((int) args[2]); + long result = Wat2WasmMachine.func_1837(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = result; + return out; + } + + public static long func_1838(int arg0, long arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = arg1; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 56)); + long[] callResult_0 = instance.getMachine().call(1837, callArgs_0); + return callResult_0[0]; + } + + public static long[] call_1838(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + int arg2 = ((int) args[2]); + long result = Wat2WasmMachine.func_1838(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = result; + return out; + } + + public static int func_1839(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = -1; + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg2, -1) != 0) { + break label_2; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 28); + break label_1; + } + label_3: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local3 + 12)); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1803, callArgs_0); + arg2 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_3; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) arg2); + local4 = -1; + break label_1; + } + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + } + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_1839(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1839(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1840(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg1); + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + arg1 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) - arg1); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) arg1); + local4 = 2; + label_1: { + label_2: { + local5 = (arg1 + arg2); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 2); + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 56)); + long[] callResult_0 = instance.getMachine().call(1839, callArgs_0); + arg1 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, local5) != 0) { + break label_2; + } + local6 = local3; + label_3: while (true) { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg1, -1) != 0) { + break label_4; + } + arg1 = 0; + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 16, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) | 32)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(2, local4) != 0) { + break label_1; + } + arg1 = (arg2 - memory.readInt((int) local6 < 0 ? local6 : local6 + 4)); + break label_1; + } + local7 = memory.readInt((int) local6 < 0 ? local6 : local6 + 4); + local8 = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, local7); + local9 = (local6 + (local8 << 3)); + local7 = (arg1 - (local8 != 0 ? local7 : 0)); + memory.writeI32((int) local9 < 0 ? local9 : local9 + 0, (int) (memory.readInt((int) local9 < 0 ? local9 : local9 + 0) + local7)); + local6 = (local6 + (local8 != 0 ? 12 : 4)); + memory.writeI32((int) local6 < 0 ? local6 : local6 + 0, (int) (memory.readInt((int) local6 < 0 ? local6 : local6 + 0) - local7)); + local6 = local9; + local5 = (local5 - arg1); + local4 = (local4 - local8); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) local9); + callArgs_1[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 56)); + long[] callResult_1 = instance.getMachine().call(1839, callArgs_1); + arg1 = ((int) callResult_1[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg1, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) arg1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (arg1 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 44))); + arg1 = arg2; + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg1; + } + + public static long[] call_1840(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1840(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1841(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + local4 = -1; + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg2, -1) != 0) { + break label_2; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 28); + break label_1; + } + label_3: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local3 + 12)); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1801, callArgs_0); + arg2 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_3; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) arg2); + local4 = -1; + break label_1; + } + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 12); + } + instance.global(0).setValue(((long) (local3 + 16))); + return local4; + } + + public static long[] call_1841(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1841(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1842(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg2); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) arg1); + label_1: { + label_2: { + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) (local3 + 4)); + callArgs_0[2] = ((long) 1); + callArgs_0[1] = ((long) (local3 + 8)); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1801, callArgs_0); + arg2 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_2; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(76, arg2) != 0 ? 8 : arg2)); + arg2 = -1; + break label_1; + } + arg2 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + } + instance.global(0).setValue(((long) (local3 + 16))); + return arg2; + } + + public static long[] call_1842(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1842(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1843(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) arg1); + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 44); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) local4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) local5); + local6 = (arg2 - com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local4)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local6); + local7 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 56); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_2; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 2); + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) local7); + long[] callResult_0 = instance.getMachine().call(1841, callArgs_0); + local4 = ((int) callResult_0[0]); + break label_1; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) local5); + callArgs_1[0] = ((long) local7); + long[] callResult_1 = instance.getMachine().call(1842, callArgs_1); + local4 = ((int) callResult_1[0]); + } + local6 = 0; + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local4, 0) != 0) { + break label_4; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) | (local4 != 0 ? 32 : 16))); + break label_3; + } + label_5: { + local7 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local4, local7) != 0) { + break label_5; + } + local6 = local4; + break label_3; + } + local6 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local6); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) (local6 + (local4 - local7))); + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 44)) != 0) { + break label_6; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local6 + 1)); + memory.writeByte((int) ((arg2 + arg1) + -1) < 0 ? ((arg2 + arg1) + -1) : ((arg2 + arg1) + -1) + 0, (byte) (((int) memory.read((int) local6 < 0 ? local6 : local6 + 0) & 0xFF))); + } + local6 = arg2; + } + instance.global(0).setValue(((long) (local3 + 16))); + return local6; + } + + public static long[] call_1843(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1843(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1844(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 56)); + long[] callResult_0 = instance.getMachine().call(1811, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_1844(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1844(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1845(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + local2 = (((int) instance.global(0).getValue()) - 32); + instance.global(0).setValue(((long) local2)); + label_1: { + label_2: { + local3 = (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 4); + callArgs_0[1] = ((long) local3); + callArgs_0[0] = ((long) 26671); + long[] callResult_0 = instance.getMachine().call(1888, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_2; + } + local4 = 0; + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 28); + break label_1; + } + label_3: { + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) 1144); + long[] callResult_1 = instance.getMachine().call(1782, callArgs_1); + local4 = ((int) callResult_1[0]); + if (local4 != 0) { + break label_3; + } + local4 = 0; + break label_1; + } + local5 = 0; + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 112); + callArgs_2[1] = ((long) 0); + callArgs_2[0] = ((long) local4); + long[] callResult_2 = instance.getMachine().call(1892, callArgs_2); + local4 = ((int) callResult_2[0]); + label_4: { + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 43); + callArgs_3[0] = ((long) arg1); + long[] callResult_3 = instance.getMachine().call(1893, callArgs_3); + if (((int) callResult_3[0]) != 0) { + break label_4; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(114, local3) != 0 ? 8 : 4); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local5); + } + label_5: { + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 101); + callArgs_4[0] = ((long) arg1); + long[] callResult_4 = instance.getMachine().call(1893, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_4[0])) != 0) { + break label_5; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 16, (int) 1); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) (local2 + 16)); + callArgs_5[1] = ((long) 2); + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1836, callArgs_5); + local3 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF); + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(97, (local3 & 255)) != 0) { + break label_6; + } + label_7: { + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 0); + callArgs_6[1] = ((long) 3); + callArgs_6[0] = ((long) arg0); + long[] callResult_6 = instance.getMachine().call(1836, callArgs_6); + arg1 = ((int) callResult_6[0]); + if ((arg1 & 1) != 0) { + break label_7; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 0, (int) (arg1 | 1)); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) local2); + callArgs_7[1] = ((long) 4); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1836, callArgs_7); + } + local5 = (local5 | 128); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) local5); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 64, (int) -1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 44, (int) 1024); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 56, (int) arg0); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 40, (int) (local4 + 120)); + label_8: { + if ((local5 & 8) != 0) { + break label_8; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) arg0); + long[] callResult_8 = instance.getMachine().call(1808, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_8[0])) != 0) { + break label_8; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 64, (int) 10); + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 36, (int) 915); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 916); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 28, (int) 917); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) 918); + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) local4); + long[] callResult_9 = instance.getMachine().call(1859, callArgs_9); + local4 = ((int) callResult_9[0]); + } + instance.global(0).setValue(((long) (local2 + 32))); + return local4; + } + + public static long[] call_1845(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1845(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1846(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + label_1: { + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 4); + callArgs_0[1] = ((long) (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0)); + callArgs_0[0] = ((long) 26671); + long[] callResult_0 = instance.getMachine().call(1888, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 28); + return 0; + } + local2 = 0; + label_2: { + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg1); + long[] callResult_1 = instance.getMachine().call(1835, callArgs_1); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) ((int) callResult_1[0])); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1812, callArgs_2); + arg0 = ((int) callResult_2[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg0, 0) != 0) { + break label_2; + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) arg1); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1845, callArgs_3); + local2 = ((int) callResult_3[0]); + if (local2 != 0) { + break label_2; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1811, callArgs_4); + local2 = 0; + } + return local2; + } + + public static long[] call_1846(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1846(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1847(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + local3 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) arg2); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1870, callArgs_0); + arg2 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local3 + 16))); + return arg2; + } + + public static long[] call_1847(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1847(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1848(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local2 = ((int) callResult_0[0]); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) arg1); + callArgs_1[2] = ((long) local2); + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1856, callArgs_1); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((int) callResult_1[0]), local2) != 0 ? -1 : 0); + } + + public static long[] call_1848(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1848(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1849(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local0 = 0; + int local1 = 0; + int local2 = 0; + label_1: { + long[] callResult_0 = instance.getMachine().call(1857, new long[0]); + local0 = memory.readInt((int) ((int) callResult_0[0]) < 0 ? ((int) callResult_0[0]) : ((int) callResult_0[0]) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local0) != 0) { + break label_1; + } + label_2: while (true) { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local0 < 0 ? local0 : local0 + 24), memory.readInt((int) local0 < 0 ? local0 : local0 + 20)) != 0) { + break label_3; + } + int ciTableIdx_1 = (int) (memory.readInt((int) local0 < 0 ? local0 : local0 + 32)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 0); + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) local0); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + } + label_4: { + local1 = memory.readInt((int) local0 < 0 ? local0 : local0 + 4); + local2 = memory.readInt((int) local0 < 0 ? local0 : local0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local1) != 0) { + break label_4; + } + int ciTableIdx_2 = (int) (memory.readInt((int) local0 < 0 ? local0 : local0 + 36)); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(20))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) 1); + callArgs_2[1] = (long) (local1 - local2); + callArgs_2[0] = ((long) local0); + long[] callResult_2 = ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + } + local0 = memory.readInt((int) local0 < 0 ? local0 : local0 + 52); + if (local0 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + label_5: { + local0 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621824); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local0) != 0) { + break label_5; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local0 < 0 ? local0 : local0 + 24), memory.readInt((int) local0 < 0 ? local0 : local0 + 20)) != 0) { + break label_6; + } + int ciTableIdx_3 = (int) (memory.readInt((int) local0 < 0 ? local0 : local0 + 32)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) local0); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + } + local1 = memory.readInt((int) local0 < 0 ? local0 : local0 + 4); + local2 = memory.readInt((int) local0 < 0 ? local0 : local0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local1) != 0) { + break label_5; + } + int ciTableIdx_4 = (int) (memory.readInt((int) local0 < 0 ? local0 : local0 + 36)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(20))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 1); + callArgs_4[1] = (long) (local1 - local2); + callArgs_4[0] = ((long) local0); + long[] callResult_4 = ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + } + label_7: { + local0 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621944); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local0) != 0) { + break label_7; + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local0 < 0 ? local0 : local0 + 24), memory.readInt((int) local0 < 0 ? local0 : local0 + 20)) != 0) { + break label_8; + } + int ciTableIdx_5 = (int) (memory.readInt((int) local0 < 0 ? local0 : local0 + 32)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) 0); + callArgs_5[1] = ((long) 0); + callArgs_5[0] = ((long) local0); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + } + local1 = memory.readInt((int) local0 < 0 ? local0 : local0 + 4); + local2 = memory.readInt((int) local0 < 0 ? local0 : local0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local1) != 0) { + break label_7; + } + int ciTableIdx_6 = (int) (memory.readInt((int) local0 < 0 ? local0 : local0 + 36)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(20))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 1); + callArgs_6[1] = (long) (local1 - local2); + callArgs_6[0] = ((long) local0); + long[] callResult_6 = ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + } + label_9: { + local0 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621704); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local0) != 0) { + break label_9; + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) local0 < 0 ? local0 : local0 + 24), memory.readInt((int) local0 < 0 ? local0 : local0 + 20)) != 0) { + break label_10; + } + int ciTableIdx_7 = (int) (memory.readInt((int) local0 < 0 ? local0 : local0 + 32)); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) 0); + callArgs_7[0] = ((long) local0); + long[] callResult_7 = ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + } + local1 = memory.readInt((int) local0 < 0 ? local0 : local0 + 4); + local2 = memory.readInt((int) local0 < 0 ? local0 : local0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local2, local1) != 0) { + break label_9; + } + int ciTableIdx_8 = (int) (memory.readInt((int) local0 < 0 ? local0 : local0 + 36)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(20))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 1); + callArgs_8[1] = (long) (local1 - local2); + callArgs_8[0] = ((long) local0); + long[] callResult_8 = ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + } + return; + } + + public static long[] call_1849(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_1849(memory, instance); + return null; + } + + public static int func_1850(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 60); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 60, (int) ((local1 + -1) | local1)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_1; + } + int ciTableIdx_0 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 16, (long) 0L); + label_2: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local1 & 4)) != 0) { + break label_2; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local1 | 32)); + return -1; + } + local2 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40) + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 44)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 8, (int) local2); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) local2); + return ((local1 << 27) >> 31); + } + + public static long[] call_1850(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1850(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1851(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 60); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 60, (int) ((local4 + -1) | local4)); + local5 = (arg2 * arg1); + label_1: { + label_2: { + local4 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 4); + local6 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local6, local4) != 0) { + break label_2; + } + local4 = local5; + break label_1; + } + local6 = (local6 - local4); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local5) != 0 ? local6 : local5); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local6); + callArgs_0[1] = ((long) local4); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1890, callArgs_0); + arg0 = ((int) callResult_0[0]); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 4, (int) (local4 + local6)); + local4 = (local5 - local6); + arg0 = (arg0 + local6); + } + local6 = (arg1 != 0 ? arg2 : 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_3; + } + label_4: while (true) { + label_5: { + label_6: { + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg3); + long[] callResult_1 = instance.getMachine().call(1850, callArgs_1); + if (((int) callResult_1[0]) != 0) { + break label_6; + } + int ciTableIdx_2 = (int) (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 28)); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local4); + callArgs_2[1] = ((long) arg0); + callArgs_2[0] = ((long) arg3); + long[] callResult_2 = ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + arg2 = ((int) callResult_2[0]); + if (arg2 != 0) { + break label_5; + } + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U((local5 - local4), arg1); + } + arg0 = (arg0 + arg2); + local4 = (local4 - arg2); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + return local6; + } + + public static long[] call_1851(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1851(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1852(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long local3 = 0L; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 3) != 0) { + break label_1; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 28); + return -1; + } + local3 = (long) arg1; + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, arg2) != 0) { + break label_2; + } + arg1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_2; + } + local3 = (local3 - (long) (arg1 - memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4))); + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0) { + break label_3; + } + int ciTableIdx_0 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + if (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) != 0) { + break label_3; + } + return -1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 16, (long) 0L); + label_4: { + int ciTableIdx_1 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(20))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = local3; + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_S(callResult_1[0], 0L) != 0) { + break label_4; + } + return -1; + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) & -17)); + return 0; + } + + public static long[] call_1852(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1852(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1853(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + long local3 = 0L; + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 36); + local2 = 1; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 128)) != 0) { + break label_1; + } + local2 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24), memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20)) != 0 ? 1 : 2); + } + label_2: { + int ciTableIdx_0 = (int) (local1); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(20))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local2); + callArgs_0[1] = 0L; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + local3 = callResult_0[0]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(local3, 0L) != 0) { + break label_2; + } + label_3: { + label_4: { + label_5: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_5; + } + arg0 = (arg0 + 4); + break label_4; + } + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_3; + } + arg0 = (arg0 + 20); + } + local3 = (local3 + (long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0) - local2)); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(local3, 2147483648L) != 0) { + break label_2; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 61); + return -1; + } + return (int) local3; + } + + public static long[] call_1853(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1853(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1854(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 60); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 60, (int) ((local1 + -1) | local1)); + label_1: { + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local1 & 8)) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local1 | 32)); + return -1; + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 4, (long) 0L); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) local1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) local1); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 16, (int) (local1 + memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 44))); + return 0; + } + + public static long[] call_1854(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1854(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1855(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + label_1: { + label_2: { + local3 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 16); + if (local3 != 0) { + break label_2; + } + local4 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg2); + long[] callResult_0 = instance.getMachine().call(1854, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + local3 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 16); + } + label_3: { + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U((local3 - local5), arg1) != 0) { + break label_3; + } + int ciTableIdx_1 = (int) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 32)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg1); + callArgs_1[1] = ((long) arg0); + callArgs_1[0] = ((long) arg2); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + return ((int) callResult_1[0]); + } + local6 = 0; + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 64), 0) != 0) { + break label_4; + } + local6 = 0; + local4 = arg0; + local3 = 0; + label_5: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, arg1) != 0) { + break label_4; + } + local3 = (local3 + 1); + local4 = (local4 + -1); + local7 = (local4 + arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(10, ((int) memory.read((int) local7 < 0 ? local7 : local7 + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + local6 = ((arg1 - local3) + 1); + int ciTableIdx_2 = (int) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 32)); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local6); + callArgs_2[1] = ((long) arg0); + callArgs_2[0] = ((long) arg2); + long[] callResult_2 = ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + local4 = ((int) callResult_2[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local6) != 0) { + break label_1; + } + arg1 = (local3 + -1); + arg0 = (local7 + 1); + local5 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 20); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) arg1); + callArgs_3[1] = ((long) arg0); + callArgs_3[0] = ((long) local5); + long[] callResult_3 = instance.getMachine().call(1890, callArgs_3); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 20, (int) (memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 20) + arg1)); + local4 = (local6 + arg1); + } + return local4; + } + + public static long[] call_1855(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1855(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1856(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + int local7 = 0; + int local8 = 0; + int local9 = 0; + local4 = (arg2 * arg1); + label_1: { + label_2: { + local5 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 16); + if (local5 != 0) { + break label_2; + } + local6 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg3); + long[] callResult_0 = instance.getMachine().call(1854, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + local5 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 16); + } + label_3: { + local7 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U((local5 - local7), local4) != 0) { + break label_3; + } + int ciTableIdx_1 = (int) (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 32)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) arg0); + callArgs_1[0] = ((long) arg3); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + local6 = ((int) callResult_1[0]); + break label_1; + } + local8 = 0; + label_4: { + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 64), 0) != 0) { + break label_5; + } + local5 = local4; + break label_4; + } + local6 = (arg0 + local4); + local8 = 0; + local5 = 0; + label_6: while (true) { + label_7: { + if ((local4 + local5) != 0) { + break label_7; + } + local5 = local4; + break label_4; + } + local5 = (local5 + -1); + local9 = (local5 + local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(10, ((int) memory.read((int) local9 < 0 ? local9 : local9 + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + break; + } + local8 = ((local4 + local5) + 1); + int ciTableIdx_2 = (int) (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 32)); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local8); + callArgs_2[1] = ((long) arg0); + callArgs_2[0] = ((long) arg3); + long[] callResult_2 = ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + local6 = ((int) callResult_2[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, local8) != 0) { + break label_1; + } + local5 = (local5 ^ -1); + arg0 = (local9 + 1); + local7 = memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 20); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) local5); + callArgs_3[1] = ((long) arg0); + callArgs_3[0] = ((long) local7); + long[] callResult_3 = instance.getMachine().call(1890, callArgs_3); + memory.writeI32((int) arg3 < 0 ? arg3 : arg3 + 20, (int) (memory.readInt((int) arg3 < 0 ? arg3 : arg3 + 20) + local5)); + local6 = (local8 + local5); + } + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local4, local6) != 0) { + break label_8; + } + return (arg1 != 0 ? arg2 : 0); + } + return com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(local6, arg1); + } + + public static long[] call_1856(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1856(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1857(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return 658508; + } + + public static long[] call_1857(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int result = Wat2WasmMachine.func_1857(memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1858(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + return; + } + + public static long[] call_1858(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_1858(memory, instance); + return null; + } + + public static int func_1859(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + long[] callResult_0 = instance.getMachine().call(1857, new long[0]); + local1 = ((int) callResult_0[0]); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 52, (int) memory.readInt((int) local1 < 0 ? local1 : local1 + 0)); + label_1: { + local2 = memory.readInt((int) local1 < 0 ? local1 : local1 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + memory.writeI32((int) local2 < 0 ? local2 : local2 + 48, (int) arg0); + } + memory.writeI32((int) local1 < 0 ? local1 : local1 + 0, (int) arg0); + instance.getMachine().call(1858, new long[0]); + return arg0; + } + + public static long[] call_1859(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1859(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1860(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + memory.writeByte((int) local2 < 0 ? local2 : local2 + 15, (byte) (arg1)); + label_1: { + label_2: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + if (local3 != 0) { + break label_2; + } + local3 = -1; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1854, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16); + } + label_3: { + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, local4) != 0) { + break label_3; + } + local3 = (arg1 & 255); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local3, memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 64)) != 0) { + break label_3; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) (local4 + 1)); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (arg1)); + break label_1; + } + local3 = -1; + int ciTableIdx_1 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 1); + callArgs_1[1] = ((long) (local2 + 15)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 15) & 0xFF); + } + instance.global(0).setValue(((long) (local2 + 16))); + return local3; + } + + public static long[] call_1860(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1860(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1861(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + label_1: { + local2 = (arg0 & 255); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 64), local2) != 0) { + break label_1; + } + local3 = memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16), local3) != 0) { + break label_1; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 20, (int) (local3 + 1)); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (arg0)); + return local2; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) local2); + callArgs_0[0] = ((long) arg1); + long[] callResult_0 = instance.getMachine().call(1860, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_1861(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1861(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1862(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) 0 < 0 ? 0 : 0 + 658184)); + long[] callResult_0 = instance.getMachine().call(1823, callArgs_0); + local1 = ((int) callResult_0[0]); + local2 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621652); + local3 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621696); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1897, callArgs_1); + long[] callArgs_2 = new long[4]; + callArgs_2[3] = ((long) 621592); + callArgs_2[2] = ((long) 1); + callArgs_2[1] = ((long) ((int) callResult_1[0])); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1856, callArgs_2); + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 621592); + callArgs_3[0] = ((long) 58); + long[] callResult_3 = instance.getMachine().call(1861, callArgs_3); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 621592); + callArgs_4[0] = ((long) 32); + long[] callResult_4 = instance.getMachine().call(1861, callArgs_4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) local1); + long[] callResult_5 = instance.getMachine().call(1897, callArgs_5); + long[] callArgs_6 = new long[4]; + callArgs_6[3] = ((long) 621592); + callArgs_6[2] = ((long) 1); + callArgs_6[1] = ((long) ((int) callResult_5[0])); + callArgs_6[0] = ((long) local1); + long[] callResult_6 = instance.getMachine().call(1856, callArgs_6); + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) 621592); + callArgs_7[0] = ((long) 10); + long[] callResult_7 = instance.getMachine().call(1861, callArgs_7); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621696, (int) local3); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621652, (int) local2); + return; + } + + public static long[] call_1862(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + Wat2WasmMachine.func_1862(arg0, memory, instance); + return null; + } + + public static int func_1863(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + local2 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 12, (int) arg1); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) arg0); + callArgs_0[0] = ((long) 621832); + long[] callResult_0 = instance.getMachine().call(1870, callArgs_0); + arg1 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local2 + 16))); + return arg1; + } + + public static long[] call_1863(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1863(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1864(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 621832); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1848, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(((int) callResult_0[0]), 0) != 0) { + break label_1; + } + return -1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(10, memory.readInt((int) 0 < 0 ? 0 : 0 + 621896)) != 0) { + break label_2; + } + arg0 = memory.readInt((int) 0 < 0 ? 0 : 0 + 621852); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) 0 < 0 ? 0 : 0 + 621848), arg0) != 0) { + break label_2; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 621852, (int) (arg0 + 1)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) (10)); + return 0; + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 10); + callArgs_1[0] = ((long) 621832); + long[] callResult_1 = instance.getMachine().call(1860, callArgs_1); + return (((int) callResult_1[0]) >> 31); + } + + public static long[] call_1864(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1864(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1865(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + local4 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local4)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 12, (int) arg3); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) arg3); + callArgs_0[2] = ((long) arg2); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1875, callArgs_0); + arg3 = ((int) callResult_0[0]); + instance.global(0).setValue(((long) (local4 + 16))); + return arg3; + } + + public static long[] call_1865(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1865(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1866(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 32, (int) 916); + label_1: { + if ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 64) != 0) { + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 56)); + long[] callResult_0 = instance.getMachine().call(1808, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 64, (int) -1); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg2); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1840, callArgs_1); + return ((int) callResult_1[0]); + } + + public static long[] call_1866(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1866(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1867(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + local3 = 1; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 127) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) (arg1)); + return 1; + } + label_3: { + label_4: { + if (memory.readInt((int) 0 < 0 ? 0 : 0 + 658480) != 0) { + break label_4; + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(57216, (arg1 & -128)) != 0) { + break label_5; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 25); + break label_3; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) (arg1)); + return 1; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 2047) != 0) { + break label_6; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 1, (byte) (((arg1 & 63) | 128))); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) (((arg1 >>> 6) | 192))); + return 2; + } + label_7: { + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 55296) != 0) { + break label_8; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(57344, (arg1 & -8192)) != 0) { + break label_7; + } + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 2, (byte) (((arg1 & 63) | 128))); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) (((arg1 >>> 12) | 224))); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 1, (byte) ((((arg1 >>> 6) & 63) | 128))); + return 3; + } + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((arg1 + -65536), 1048575) != 0) { + break label_9; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (((arg1 & 63) | 128))); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) (((arg1 >>> 18) | 240))); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 2, (byte) ((((arg1 >>> 6) & 63) | 128))); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 1, (byte) ((((arg1 >>> 12) & 63) | 128))); + return 4; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 25); + } + local3 = -1; + } + return local3; + } + + public static long[] call_1867(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1867(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1868(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + if (arg0 != 0) { + break label_1; + } + return 0; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 0); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1867, callArgs_0); + return ((int) callResult_0[0]); + } + + public static long[] call_1868(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1868(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static double func_1869(double arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long local2 = 0L; + int local3 = 0; + label_1: { + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I64_REINTERPRET_F64(arg0); + local3 = ((int) (local2 >>> 52L) & 2047); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(2047, local3) != 0) { + break label_1; + } + label_2: { + if (local3 != 0) { + break label_2; + } + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_NE(arg0, 0.0) != 0) { + break label_3; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) 0); + return arg0; + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong((arg0 * 1.8446744073709552E19)); + long[] callResult_0 = instance.getMachine().call(1869, callArgs_0); + arg0 = com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_0[0]); + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) (memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) + -64)); + return arg0; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) (local3 + -1022)); + arg0 = com.dylibso.chicory.runtime.OpcodeImpl.F64_REINTERPRET_I64(((local2 & -9218868437227405313L) | 4602678819172646912L)); + } + return arg0; + } + + public static long[] call_1869(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + double arg0 = com.dylibso.chicory.wasm.types.Value.longToDouble(args[0]); + int arg1 = ((int) args[1]); + double result = Wat2WasmMachine.func_1869(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(result); + return out; + } + + public static int func_1870(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = (((int) instance.global(0).getValue()) - 208); + instance.global(0).setValue(((long) local3)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 204, (int) arg2); + memory.writeLong((int) ((local3 + 160) + 32) < 0 ? ((local3 + 160) + 32) : ((local3 + 160) + 32) + 0, (long) 0L); + memory.writeLong((int) (local3 + 184) < 0 ? (local3 + 184) : (local3 + 184) + 0, (long) 0L); + memory.writeLong((int) (local3 + 176) < 0 ? (local3 + 176) : (local3 + 176) + 0, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 168, (long) 0L); + memory.writeLong((int) local3 < 0 ? local3 : local3 + 160, (long) 0L); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 200, (int) arg2); + label_1: { + label_2: { + long[] callArgs_0 = new long[5]; + callArgs_0[4] = ((long) (local3 + 160)); + callArgs_0[3] = ((long) (local3 + 80)); + callArgs_0[2] = ((long) (local3 + 200)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) 0); + long[] callResult_0 = instance.getMachine().call(1871, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(((int) callResult_0[0]), 0) != 0) { + break label_2; + } + arg0 = -1; + break label_1; + } + local4 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 60), 0) != 0) { + break label_3; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local4 & -33)); + } + label_4: { + label_5: { + label_6: { + label_7: { + if (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 44) != 0) { + break label_7; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 44, (int) 80); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) 0); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 16, (long) 0L); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 40, (int) local3); + break label_6; + } + local5 = 0; + if (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 16) != 0) { + break label_5; + } + } + arg2 = -1; + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1854, callArgs_1); + if (((int) callResult_1[0]) != 0) { + break label_4; + } + } + long[] callArgs_2 = new long[5]; + callArgs_2[4] = ((long) (local3 + 160)); + callArgs_2[3] = ((long) (local3 + 80)); + callArgs_2[2] = ((long) (local3 + 200)); + callArgs_2[1] = ((long) arg1); + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1871, callArgs_2); + arg2 = ((int) callResult_2[0]); + } + arg1 = (local4 & 32); + label_8: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_8; + } + int ciTableIdx_3 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 32)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) 0); + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 44, (int) 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 40, (int) local5); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) 0); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 16, (long) 0L); + arg2 = (local5 != 0 ? arg2 : -1); + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) (local5 | arg1)); + arg0 = ((local5 & 32) != 0 ? -1 : arg2); + } + instance.global(0).setValue(((long) (local3 + 208))); + return arg0; + } + + public static long[] call_1870(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1870(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1871(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[41]; + long[] lL = new long[3]; + double[] dL = new double[2]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = arg2; + iL[3] = arg3; + iL[4] = arg4; + iL[6] = (((int) instance.global(0).getValue()) - 880); + instance.global(0).setValue(((long) iL[6])); + iL[7] = ((iL[6] + 68) + 12); + iL[8] = (0 - (iL[6] + 112)); + iL[9] = (iL[6] + -3988); + iL[10] = (iL[6] + 55); + iL[11] = ((iL[6] + 80) ^ -2); + iL[12] = ((iL[6] + 68) + 11); + iL[13] = ((iL[6] + 80) | 8); + iL[14] = ((iL[6] + 80) | 9); + iL[15] = (-10 - (iL[6] + 68)); + iL[16] = ((iL[6] + 68) + 10); + iL[17] = (iL[6] + 56); + iL[18] = 0; + iL[19] = 0; + iL[20] = 0; + label_1: { + label_2: { + label_3: { + label_4: while (true) { + iL[21] = iL[1]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[20], (iL[19] ^ 2147483647)) != 0) { + break label_3; + } + iL[19] = (iL[20] + iL[19]); + label_5: { + label_6: { + int _d1 = func_1871__h1(iL, lL, dL, memory, instance); + if (_d1 == 1) + break label_3; + if (_d1 == 2) + continue label_4; + if (_d1 == 3) + break label_1; + if (_d1 == 4) + break label_2; + if (_d1 == 5) + break label_5; + } + iL[24] = (iL[35] + (((iL[32] << 26) >> 31) & 9)); + label_227: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[25], 11) != 0) { + break label_227; + } + label_228: { + label_229: { + iL[20] = (12 - iL[25]); + iL[22] = (iL[20] & 7); + if (iL[22] != 0) { + break label_229; + } + dL[1] = 16.0; + break label_228; + } + iL[20] = (iL[25] + -12); + dL[1] = 16.0; + label_230: while (true) { + iL[20] = (iL[20] + 1); + dL[1] = (dL[1] * 16.0); + iL[22] = (iL[22] + -1); + if (iL[22] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_230; + } + break; + } + iL[20] = (0 - iL[20]); + } + label_231: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((iL[25] + -5), 7) != 0) { + break label_231; + } + label_232: while (true) { + dL[1] = ((((((((dL[1] * 16.0) * 16.0) * 16.0) * 16.0) * 16.0) * 16.0) * 16.0) * 16.0); + iL[20] = (iL[20] + -8); + if (iL[20] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_232; + } + break; + } + } + label_233: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(45, ((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 0) & 0xFF)) != 0) { + break label_233; + } + dL[0] = -(dL[1] + (-dL[0] - dL[1])); + break label_227; + } + dL[0] = ((dL[0] + dL[1]) - dL[1]); + } + label_234: { + label_235: { + iL[26] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 108); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[26]) != 0) { + break label_235; + } + iL[20] = (iL[26] >> 31); + iL[20] = ((iL[26] ^ iL[20]) - iL[20]); + iL[22] = 0; + label_236: while (true) { + iL[23] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[20], 10); + memory.writeByte((int) (((iL[6] + 68) + iL[22]) + 11) < 0 ? (((iL[6] + 68) + iL[22]) + 11) : (((iL[6] + 68) + iL[22]) + 11) + 0, (byte) (((iL[20] - (iL[23] * 10)) | 48))); + iL[22] = (iL[22] + -1); + iL[21] = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 9); + iL[20] = iL[23]; + if (iL[21] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_236; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[22]) != 0) { + break label_235; + } + iL[20] = (((iL[6] + 68) + iL[22]) + 12); + break label_234; + } + memory.writeByte((int) iL[6] < 0 ? iL[6] : iL[6] + 79, (byte) (48)); + iL[20] = iL[12]; + } + iL[28] = (iL[33] | 2); + iL[23] = (iL[32] & 32); + iL[30] = (iL[20] + -2); + memory.writeByte((int) iL[30] < 0 ? iL[30] : iL[30] + 0, (byte) ((iL[32] + 15))); + memory.writeByte((int) (iL[20] + -1) < 0 ? (iL[20] + -1) : (iL[20] + -1) + 0, (byte) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[26], 0) != 0 ? 45 : 43))); + iL[21] = (iL[31] & 8); + iL[22] = (iL[6] + 80); + label_237: while (true) { + iL[20] = iL[22]; + label_238: { + label_239: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(com.dylibso.chicory.runtime.OpcodeImpl.F64_LT(com.dylibso.chicory.runtime.OpcodeImpl.F64_ABS(dL[0]), 2.147483648E9)) != 0) { + break label_239; + } + iL[22] = com.dylibso.chicory.runtime.OpcodeImpl.I32_TRUNC_F64_S(dL[0]); + break label_238; + } + iL[22] = -2147483648; + } + memory.writeByte((int) iL[20] < 0 ? iL[20] : iL[20] + 0, (byte) ((((int) memory.read((int) (iL[22] + 62112) < 0 ? (iL[22] + 62112) : (iL[22] + 62112) + 0) & 0xFF) | iL[23]))); + dL[0] = ((dL[0] - com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(iL[22])) * 16.0); + label_240: { + iL[22] = (iL[20] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, (iL[22] - (iL[6] + 80))) != 0) { + break label_240; + } + label_241: { + if (iL[21] != 0) { + break label_241; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[25], 0) != 0) { + break label_241; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_EQ(dL[0], 0.0) != 0) { + break label_240; + } + } + memory.writeByte((int) iL[20] < 0 ? iL[20] : iL[20] + 1, (byte) (46)); + iL[22] = (iL[20] + 2); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_NE(dL[0], 0.0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_237; + } + break; + } + iL[26] = (iL[7] - iL[30]); + iL[20] = (iL[26] + iL[28]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((2147483645 - iL[20]), iL[25]) != 0) { + break label_3; + } + iL[23] = (iL[22] - (iL[6] + 80)); + iL[21] = (iL[25] != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((iL[11] + iL[22]), iL[25]) != 0 ? (iL[25] + 2) : iL[23]) : iL[23]); + iL[29] = (iL[21] + iL[20]); + label_242: { + iL[22] = (iL[31] & 73728); + if (iL[22] != 0) { + break label_242; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[27], iL[29]) != 0) { + break label_242; + } + iL[20] = (iL[27] - iL[29]); + iL[25] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[20], 256); + long[] callArgs_68 = new long[3]; + callArgs_68[2] = ((long) (iL[25] != 0 ? iL[20] : 256)); + callArgs_68[1] = ((long) 32); + callArgs_68[0] = ((long) (iL[6] + 624)); + long[] callResult_68 = instance.getMachine().call(1892, callArgs_68); + label_243: { + if (iL[25] != 0) { + break label_243; + } + label_244: while (true) { + label_245: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_245; + } + long[] callArgs_69 = new long[3]; + callArgs_69[2] = ((long) iL[0]); + callArgs_69[1] = ((long) 256); + callArgs_69[0] = ((long) (iL[6] + 624)); + long[] callResult_69 = instance.getMachine().call(1855, callArgs_69); + } + iL[20] = (iL[20] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_244; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_242; + } + long[] callArgs_70 = new long[3]; + callArgs_70[2] = ((long) iL[0]); + callArgs_70[1] = ((long) iL[20]); + callArgs_70[0] = ((long) (iL[6] + 624)); + long[] callResult_70 = instance.getMachine().call(1855, callArgs_70); + } + label_246: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_246; + } + long[] callArgs_71 = new long[3]; + callArgs_71[2] = ((long) iL[0]); + callArgs_71[1] = ((long) iL[28]); + callArgs_71[0] = ((long) iL[24]); + long[] callResult_71 = instance.getMachine().call(1855, callArgs_71); + } + label_247: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(65536, iL[22]) != 0) { + break label_247; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[27], iL[29]) != 0) { + break label_247; + } + iL[20] = (iL[27] - iL[29]); + iL[25] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[20], 256); + long[] callArgs_72 = new long[3]; + callArgs_72[2] = ((long) (iL[25] != 0 ? iL[20] : 256)); + callArgs_72[1] = ((long) 48); + callArgs_72[0] = ((long) (iL[6] + 624)); + long[] callResult_72 = instance.getMachine().call(1892, callArgs_72); + label_248: { + if (iL[25] != 0) { + break label_248; + } + label_249: while (true) { + label_250: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_250; + } + long[] callArgs_73 = new long[3]; + callArgs_73[2] = ((long) iL[0]); + callArgs_73[1] = ((long) 256); + callArgs_73[0] = ((long) (iL[6] + 624)); + long[] callResult_73 = instance.getMachine().call(1855, callArgs_73); + } + iL[20] = (iL[20] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_249; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_247; + } + long[] callArgs_74 = new long[3]; + callArgs_74[2] = ((long) iL[0]); + callArgs_74[1] = ((long) iL[20]); + callArgs_74[0] = ((long) (iL[6] + 624)); + long[] callResult_74 = instance.getMachine().call(1855, callArgs_74); + } + label_251: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_251; + } + long[] callArgs_75 = new long[3]; + callArgs_75[2] = ((long) iL[0]); + callArgs_75[1] = ((long) iL[23]); + callArgs_75[0] = ((long) (iL[6] + 80)); + long[] callResult_75 = instance.getMachine().call(1855, callArgs_75); + } + label_252: { + iL[20] = (iL[21] - iL[23]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[20], 1) != 0) { + break label_252; + } + iL[23] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[20], 256); + long[] callArgs_76 = new long[3]; + callArgs_76[2] = ((long) (iL[23] != 0 ? iL[20] : 256)); + callArgs_76[1] = ((long) 48); + callArgs_76[0] = ((long) (iL[6] + 624)); + long[] callResult_76 = instance.getMachine().call(1892, callArgs_76); + label_253: { + if (iL[23] != 0) { + break label_253; + } + label_254: while (true) { + label_255: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_255; + } + long[] callArgs_77 = new long[3]; + callArgs_77[2] = ((long) iL[0]); + callArgs_77[1] = ((long) 256); + callArgs_77[0] = ((long) (iL[6] + 624)); + long[] callResult_77 = instance.getMachine().call(1855, callArgs_77); + } + iL[20] = (iL[20] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_254; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_252; + } + long[] callArgs_78 = new long[3]; + callArgs_78[2] = ((long) iL[0]); + callArgs_78[1] = ((long) iL[20]); + callArgs_78[0] = ((long) (iL[6] + 624)); + long[] callResult_78 = instance.getMachine().call(1855, callArgs_78); + } + label_256: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_256; + } + long[] callArgs_79 = new long[3]; + callArgs_79[2] = ((long) iL[0]); + callArgs_79[1] = ((long) iL[26]); + callArgs_79[0] = ((long) iL[30]); + long[] callResult_79 = instance.getMachine().call(1855, callArgs_79); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8192, iL[22]) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[27], iL[29]) != 0) { + break label_5; + } + iL[20] = (iL[27] - iL[29]); + iL[22] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[20], 256); + long[] callArgs_80 = new long[3]; + callArgs_80[2] = ((long) (iL[22] != 0 ? iL[20] : 256)); + callArgs_80[1] = ((long) 32); + callArgs_80[0] = ((long) (iL[6] + 624)); + long[] callResult_80 = instance.getMachine().call(1892, callArgs_80); + label_257: { + if (iL[22] != 0) { + break label_257; + } + label_258: while (true) { + label_259: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_259; + } + long[] callArgs_81 = new long[3]; + callArgs_81[2] = ((long) iL[0]); + callArgs_81[1] = ((long) 256); + callArgs_81[0] = ((long) (iL[6] + 624)); + long[] callResult_81 = instance.getMachine().call(1855, callArgs_81); + } + iL[20] = (iL[20] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_258; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_5; + } + long[] callArgs_82 = new long[3]; + callArgs_82[2] = ((long) iL[0]); + callArgs_82[1] = ((long) iL[20]); + callArgs_82[0] = ((long) (iL[6] + 624)); + long[] callResult_82 = instance.getMachine().call(1855, callArgs_82); + } + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[29], iL[27]) != 0 ? iL[29] : iL[27]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[20], 0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + memory.writeI32((int) 658184 < 0 ? 658184 : 658184 + 0, (int) 61); + } + iL[19] = -1; + } + instance.global(0).setValue(((long) (iL[6] + 880))); + return iL[19]; + } + + public static long[] call_1871(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + int result = Wat2WasmMachine.func_1871(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1872(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + label_2: { + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + label_13: { + label_14: { + label_15: { + label_16: { + label_17: { + label_18: { + label_19: { + switch((arg1 + -9)) { + case 0: + { + break label_2; + } + case 1: + { + break label_19; + } + case 2: + { + break label_18; + } + case 3: + { + break label_15; + } + case 4: + { + break label_17; + } + case 5: + { + break label_16; + } + case 6: + { + break label_14; + } + case 7: + { + break label_13; + } + case 8: + { + break label_12; + } + case 9: + { + break label_11; + } + case 10: + { + break label_10; + } + case 11: + { + break label_9; + } + case 12: + { + break label_8; + } + case 13: + { + break label_7; + } + case 14: + { + break label_6; + } + case 15: + { + break label_5; + } + case 16: + { + break label_4; + } + case 17: + { + break label_3; + } + default: + { + break label_1; + } + } + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) (long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFFFFFFFFL)); + return; + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) (long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFFFFFFFFL)); + return; + } + arg1 = ((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 7) & -8); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 8)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) (long) (int) (short) memory.readShort((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) (long) ((int) memory.readShort((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFFFF)); + return; + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) (long) (int) (byte) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) (long) ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)); + return; + } + arg1 = ((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 7) & -8); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 8)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFFFFFFFFL)); + return; + } + arg1 = ((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 7) & -8); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 8)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + arg1 = ((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 7) & -8); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 8)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) (long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 0, (long) ((long) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFFFFFFFFL)); + return; + } + arg1 = ((memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0) + 7) & -8); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 8)); + memory.writeF64((int) arg0 < 0 ? arg0 : arg0 + 0, (double) memory.readDouble((int) arg1 < 0 ? arg1 : arg1 + 0)); + return; + } + instance.getMachine().call(1874, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + arg1 = memory.readInt((int) arg2 < 0 ? arg2 : arg2 + 0); + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) (arg1 + 4)); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + } + return; + } + + public static long[] call_1872(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + Wat2WasmMachine.func_1872(arg0, arg1, arg2, memory, instance); + return null; + } + + public static void func_1873(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + local5 = (((int) instance.global(0).getValue()) - 256); + instance.global(0).setValue(((long) local5)); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(arg2, arg3) != 0) { + break label_1; + } + if ((arg4 & 73728) != 0) { + break label_1; + } + arg3 = (arg2 - arg3); + arg4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg3, 256); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (arg4 != 0 ? arg3 : 256)); + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) local5); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + arg2 = ((int) callResult_0[0]); + label_2: { + if (arg4 != 0) { + break label_2; + } + label_3: while (true) { + label_4: { + if ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 32) != 0) { + break label_4; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg0); + callArgs_1[1] = ((long) 256); + callArgs_1[0] = ((long) arg2); + long[] callResult_1 = instance.getMachine().call(1855, callArgs_1); + } + arg3 = (arg3 + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg3, 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + if ((((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF) & 32) != 0) { + break label_1; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) arg0); + callArgs_2[1] = ((long) arg3); + callArgs_2[0] = ((long) arg2); + long[] callResult_2 = instance.getMachine().call(1855, callArgs_2); + } + instance.global(0).setValue(((long) (local5 + 256))); + return; + } + + public static long[] call_1873(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + Wat2WasmMachine.func_1873(arg0, arg1, arg2, arg3, arg4, memory, instance); + return null; + } + + public static void func_1874(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) 621592); + callArgs_0[0] = ((long) 32383); + long[] callResult_0 = instance.getMachine().call(1848, callArgs_0); + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + + public static long[] call_1874(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + Wat2WasmMachine.func_1874(memory, instance); + return null; + } + + public static int func_1875(int arg0, int arg1, int arg2, int arg3, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local4 = 0; + int local5 = 0; + int local6 = 0; + local4 = (((int) instance.global(0).getValue()) - 128); + instance.global(0).setValue(((long) local4)); + local5 = (arg1 != 0 ? arg0 : (local4 + 126)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 112, (int) local5); + arg0 = -1; + local6 = (arg1 + -1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 116, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local6, arg1) != 0 ? 0 : local6)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 112); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) local4); + long[] callResult_0 = instance.getMachine().call(1892, callArgs_0); + local4 = ((int) callResult_0[0]); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 64, (int) -1); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 32, (int) 920); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 68, (int) (local4 + 112)); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 40, (int) (local4 + 127)); + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg1, -1) != 0) { + break label_2; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 61); + break label_1; + } + memory.writeByte((int) local5 < 0 ? local5 : local5 + 0, (byte) (0)); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) arg3); + callArgs_1[1] = ((long) arg2); + callArgs_1[0] = ((long) local4); + long[] callResult_1 = instance.getMachine().call(1870, callArgs_1); + arg0 = ((int) callResult_1[0]); + } + instance.global(0).setValue(((long) (local4 + 128))); + return arg0; + } + + public static long[] call_1875(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int result = Wat2WasmMachine.func_1875(arg0, arg1, arg2, arg3, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1876(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + label_1: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 68); + local4 = memory.readInt((int) local3 < 0 ? local3 : local3 + 4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 24); + local6 = (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 20) - local5); + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, local6) != 0 ? local4 : local6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local6) != 0) { + break label_1; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) local6); + callArgs_0[1] = ((long) local5); + callArgs_0[0] = ((long) memory.readInt((int) local3 < 0 ? local3 : local3 + 0)); + long[] callResult_0 = instance.getMachine().call(1890, callArgs_0); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + local6)); + local4 = (memory.readInt((int) local3 < 0 ? local3 : local3 + 4) - local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) local4); + } + local6 = memory.readInt((int) local3 < 0 ? local3 : local3 + 0); + label_2: { + local4 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, arg2) != 0 ? local4 : arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) local4); + callArgs_1[1] = ((long) arg1); + callArgs_1[0] = ((long) local6); + long[] callResult_1 = instance.getMachine().call(1890, callArgs_1); + local6 = (memory.readInt((int) local3 < 0 ? local3 : local3 + 0) + local4); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) local6); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) (memory.readInt((int) local3 < 0 ? local3 : local3 + 4) - local4)); + } + memory.writeByte((int) local6 < 0 ? local6 : local6 + 0, (byte) (0)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 24, (int) local3); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 20, (int) local3); + return arg2; + } + + public static long[] call_1876(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1876(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1877(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + int local3 = 0; + int local4 = 0; + label_1: while (true) { + local1 = (int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0); + local2 = (local1 + -14); + local3 = (arg0 + 1); + arg0 = local3; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(32, local1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + arg0 = local3; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local2, -6) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_1; + } + break; + } + local4 = 0; + label_2: { + label_3: { + label_4: { + label_5: { + switch((local1 + -43)) { + case 0: + { + break label_3; + } + case 1: + { + break label_5; + } + case 2: + { + break label_4; + } + default: + { + break label_5; + } + } + } + local3 = (local3 + -1); + local4 = 0; + break label_2; + } + local4 = 1; + } + local1 = (int) (byte) memory.read((int) local3 < 0 ? local3 : local3 + 0); + } + local2 = 0; + label_6: { + local1 = (local1 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, 9) != 0) { + break label_6; + } + arg0 = (local3 + 1); + local2 = 0; + label_7: while (true) { + local2 = ((local2 * 10) - local1); + local1 = (int) (byte) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0); + arg0 = (arg0 + 1); + local1 = (local1 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local1, 10) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + return (local4 != 0 ? local2 : (0 - local2)); + } + + public static long[] call_1877(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1877(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1878(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + local1 = (((int) instance.global(0).getValue()) - 16); + instance.global(0).setValue(((long) local1)); + local2 = -1; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1850, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_1; + } + int ciTableIdx_1 = (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 28)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 1); + callArgs_1[1] = ((long) (local1 + 15)); + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_1[0])) != 0) { + break label_1; + } + local2 = ((int) memory.read((int) local1 < 0 ? local1 : local1 + 15) & 0xFF); + } + instance.global(0).setValue(((long) (local1 + 16))); + return local2; + } + + public static long[] call_1878(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1878(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static void func_1879(int arg0, long arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) arg1); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 96, (long) (long) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40) - local2)); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(arg1) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_S((long) (local3 - local2), arg1) != 0) { + break label_1; + } + local3 = (local2 + (int) arg1); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 84, (int) local3); + return; + } + + public static long[] call_1879(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + long arg1 = args[1]; + Wat2WasmMachine.func_1879(arg0, arg1, memory, instance); + return null; + } + + public static int func_1880(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + long local3 = 0L; + long local4 = 0L; + int local5 = 0; + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + local3 = (memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 96) + (long) (local1 - local2)); + label_1: { + label_2: { + label_3: { + local4 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(local4) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_S(local3, local4) != 0) { + break label_2; + } + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1878, callArgs_0); + local2 = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local2, -1) != 0) { + break label_1; + } + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + } + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 88, (long) -1L); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 84, (int) local1); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 96, (long) (local3 + (long) (local2 - local1))); + return -1; + } + local3 = (local3 + 1L); + local1 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 8); + label_4: { + local4 = memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQ(0L, local4) != 0) { + break label_4; + } + local4 = (local4 - local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_S(local4, (long) (local5 - local1)) != 0) { + break label_4; + } + local5 = (local1 + (int) local4); + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 84, (int) local5); + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 40); + memory.writeLong((int) arg0 < 0 ? arg0 : arg0 + 96, (long) (local3 + (long) (local5 - local1))); + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local1, local5) != 0) { + break label_5; + } + memory.writeByte((int) (local1 + -1) < 0 ? (local1 + -1) : (local1 + -1) + 0, (byte) (local2)); + } + return local2; + } + + public static long[] call_1880(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1880(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static double func_1881(double arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 1024) != 0) { + break label_2; + } + arg0 = (arg0 * 8.98846567431158E307); + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg1, 2047) != 0) { + break label_3; + } + arg1 = (arg1 + -1023); + break label_1; + } + arg0 = (arg0 * 8.98846567431158E307); + arg1 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(arg1, 3069) != 0 ? arg1 : 3069) + -2046); + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg1, -1023) != 0) { + break label_1; + } + arg0 = (arg0 * 2.004168360008973E-292); + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(arg1, -1992) != 0) { + break label_4; + } + arg1 = (arg1 + 969); + break label_1; + } + arg0 = (arg0 * 2.004168360008973E-292); + arg1 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(arg1, -2960) != 0 ? arg1 : -2960) + 1938); + } + return (arg0 * com.dylibso.chicory.runtime.OpcodeImpl.F64_REINTERPRET_I64((com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((arg1 + 1023)) << 52L))); + } + + public static long[] call_1881(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + double arg0 = com.dylibso.chicory.wasm.types.Value.longToDouble(args[0]); + int arg1 = ((int) args[1]); + double result = Wat2WasmMachine.func_1881(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(result); + return out; + } + + public static double func_1882(double arg0, double arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long local2 = 0L; + long local3 = 0L; + long local4 = 0L; + int local5 = 0; + long local6 = 0L; + int local7 = 0; + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_NE(arg1, arg1) != 0) { + break label_2; + } + local2 = com.dylibso.chicory.runtime.OpcodeImpl.I64_REINTERPRET_F64(arg1); + local3 = (local2 << 1L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(local3) != 0) { + break label_2; + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I64_REINTERPRET_F64(arg0); + local5 = ((int) (local4 >>> 52L) & 2047); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(2047, local5) != 0) { + break label_1; + } + } + arg1 = (arg0 * arg1); + return (arg1 / arg1); + } + label_3: { + local6 = (local4 << 1L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local6, local3) != 0) { + break label_3; + } + return (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQ(local3, local6) != 0 ? (arg0 * 0.0) : arg0); + } + local7 = ((int) (local2 >>> 52L) & 2047); + label_4: { + label_5: { + if (local5 != 0) { + break label_5; + } + local5 = 0; + label_6: { + local3 = (local4 << 12L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(local3, 0L) != 0) { + break label_6; + } + label_7: while (true) { + local5 = (local5 + -1); + local3 = (local3 << 1L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_S(local3, -1L) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + local3 = (local4 << com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((1 - local5))); + break label_4; + } + local3 = ((local4 & 4503599627370495L) | 4503599627370496L); + } + label_8: { + label_9: { + if (local7 != 0) { + break label_9; + } + local7 = 0; + label_10: { + local6 = (local2 << 12L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(local6, 0L) != 0) { + break label_10; + } + label_11: while (true) { + local7 = (local7 + -1); + local6 = (local6 << 1L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_S(local6, -1L) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + } + local2 = (local2 << com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((1 - local7))); + break label_8; + } + local2 = ((local2 & 4503599627370495L) | 4503599627370496L); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(local5, local7) != 0) { + break label_12; + } + label_13: while (true) { + label_14: { + local6 = (local3 - local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(local6, 0L) != 0) { + break label_14; + } + local3 = local6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(0L, local6) != 0) { + break label_14; + } + return (arg0 * 0.0); + } + local3 = (local3 << 1L); + local5 = (local5 + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local5, local7) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_13; + } + break; + } + local5 = local7; + } + label_15: { + local6 = (local3 - local2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(local6, 0L) != 0) { + break label_15; + } + local3 = local6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(0L, local6) != 0) { + break label_15; + } + return (arg0 * 0.0); + } + label_16: { + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_U(local3, 4503599627370495L) != 0) { + break label_17; + } + local6 = local3; + break label_16; + } + label_18: while (true) { + local5 = (local5 + -1); + local7 = com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(local3, 2251799813685248L); + local6 = (local3 << 1L); + local3 = local6; + if (local7 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + } + local3 = (local4 & -9223372036854775808L); + label_19: { + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, 1) != 0) { + break label_20; + } + local6 = ((local6 + -4503599627370496L) | (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local5) << 52L)); + break label_19; + } + local6 = (local6 >>> com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((1 - local5))); + } + return com.dylibso.chicory.runtime.OpcodeImpl.F64_REINTERPRET_I64((local6 | local3)); + } + + public static long[] call_1882(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + double arg0 = com.dylibso.chicory.wasm.types.Value.longToDouble(args[0]); + double arg1 = com.dylibso.chicory.wasm.types.Value.longToDouble(args[1]); + double result = Wat2WasmMachine.func_1882(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(result); + return out; + } + + public static double func_1883(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] iL = new int[21]; + long[] lL = new long[3]; + double[] dL = new double[4]; + iL[0] = arg0; + iL[1] = arg1; + iL[2] = arg2; + iL[5] = (((int) instance.global(0).getValue()) - 512); + instance.global(0).setValue(((long) iL[5])); + iL[6] = -149; + iL[7] = 24; + iL[8] = 0; + dL[0] = 0.0; + label_1: { + label_2: { + label_3: { + { + int _sel = iL[1]; + int _sw; + if (_sel < 2) { + _sw = func_1883_helper1(_sel, iL, lL, dL, memory, instance); + } else { + _sw = func_1883_helper2(_sel, iL, lL, dL, memory, instance); + } + if (_sw == 1) + break label_2; + if (_sw == 2) + break label_3; + if (_sw == 3) + break label_1; + } + } + iL[6] = -1074; + iL[7] = 53; + iL[8] = 1; + } + iL[9] = (iL[0] + 4); + label_4: { + label_5: { + label_6: while (true) { + label_7: { + label_8: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_8; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_7; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) iL[0]); + long[] callResult_0 = instance.getMachine().call(1880, callArgs_0); + iL[1] = ((int) callResult_0[0]); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((iL[1] + -9), 5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + label_9: { + switch((iL[1] + -32)) { + case 0: + { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_6; + } + case 1: + { + break label_5; + } + case 2: + { + break label_5; + } + case 3: + { + break label_5; + } + case 4: + { + break label_5; + } + case 5: + { + break label_5; + } + case 6: + { + break label_5; + } + case 7: + { + break label_5; + } + case 8: + { + break label_5; + } + case 9: + { + break label_5; + } + case 10: + { + break label_5; + } + case 11: + { + break label_9; + } + case 12: + { + break label_5; + } + case 13: + { + break label_9; + } + default: + { + break label_5; + } + } + } + break; + } + iL[10] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, iL[1]) != 0 ? -1 : 1); + label_10: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_10; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_4; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) iL[0]); + long[] callResult_1 = instance.getMachine().call(1880, callArgs_1); + iL[1] = ((int) callResult_1[0]); + break label_4; + } + iL[10] = 1; + } + label_11: { + int _d0 = func_1883__h0(iL, lL, dL, memory, instance); + if (_d0 == 1) + break label_1; + } + label_60: { + label_61: { + label_62: { + label_63: { + label_64: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(48, iL[1]) != 0) { + break label_64; + } + label_65: { + label_66: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_66; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_65; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) iL[0]); + long[] callResult_15 = instance.getMachine().call(1880, callArgs_15); + iL[1] = ((int) callResult_15[0]); + } + label_67: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(88, (iL[1] & -33)) != 0) { + break label_67; + } + long[] callArgs_16 = new long[5]; + callArgs_16[4] = ((long) iL[2]); + callArgs_16[3] = ((long) iL[10]); + callArgs_16[2] = ((long) iL[6]); + callArgs_16[1] = ((long) iL[7]); + callArgs_16[0] = ((long) iL[0]); + long[] callResult_16 = instance.getMachine().call(1884, callArgs_16); + dL[0] = com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_16[0]); + break label_1; + } + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + label_68: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(memory.readLong((int) iL[0] < 0 ? iL[0] : iL[0] + 88), 0L) != 0) { + break label_68; + } + iL[1] = (iL[1] + -1); + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) iL[1]); + } + iL[14] = (0 - iL[6]); + label_69: { + label_70: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_70; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_69; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) iL[0]); + long[] callResult_17 = instance.getMachine().call(1880, callArgs_17); + iL[1] = ((int) callResult_17[0]); + } + iL[15] = (iL[14] - iL[7]); + label_71: while (true) { + label_72: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(48, iL[1]) != 0) { + break label_72; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(46, iL[1]) != 0) { + break label_62; + } + iL[16] = 1; + break label_63; + } + label_73: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_73; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_71; + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) iL[0]); + long[] callResult_18 = instance.getMachine().call(1880, callArgs_18); + iL[1] = ((int) callResult_18[0]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_71; + } + } + iL[16] = 0; + iL[14] = (0 - iL[6]); + iL[15] = (iL[14] - iL[7]); + lL[0] = 0L; + iL[17] = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(46, iL[1]) != 0) { + break label_60; + } + } + label_74: { + label_75: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_75; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_74; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) iL[0]); + long[] callResult_19 = instance.getMachine().call(1880, callArgs_19); + iL[1] = ((int) callResult_19[0]); + } + label_76: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(48, iL[1]) != 0) { + break label_76; + } + iL[17] = 1; + break label_61; + } + lL[0] = 0L; + label_77: while (true) { + label_78: { + label_79: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_79; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_78; + } + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) iL[0]); + long[] callResult_20 = instance.getMachine().call(1880, callArgs_20); + iL[1] = ((int) callResult_20[0]); + } + lL[0] = (lL[0] + -1L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(48, iL[1]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_77; + } + break; + } + iL[16] = 1; + iL[17] = 1; + break label_60; + } + iL[17] = 0; + iL[16] = 1; + } + lL[0] = 0L; + } + iL[18] = 0; + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) 0); + iL[12] = (iL[1] + -48); + label_80: { + label_81: { + label_82: { + label_83: { + label_84: { + label_85: { + iL[11] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(46, iL[1]); + if (iL[11] != 0) { + break label_85; + } + lL[1] = 0L; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[12], 9) != 0) { + break label_85; + } + iL[13] = 0; + iL[19] = 0; + break label_84; + } + lL[1] = 0L; + iL[19] = 0; + iL[13] = 0; + iL[18] = 0; + label_86: while (true) { + label_87: { + label_88: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[11] & 1)) != 0) { + break label_88; + } + label_89: { + if (iL[17] != 0) { + break label_89; + } + lL[0] = lL[1]; + iL[17] = 1; + break label_87; + } + iL[11] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[16]); + break label_83; + } + lL[1] = (lL[1] + 1L); + label_90: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[13], 124) != 0) { + break label_90; + } + iL[16] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(48, iL[1]); + iL[20] = (int) lL[1]; + iL[11] = (iL[5] + (iL[13] << 2)); + label_91: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[19]) != 0) { + break label_91; + } + iL[12] = ((iL[1] + (memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0) * 10)) + -48); + } + iL[18] = (iL[16] != 0 ? iL[18] : iL[20]); + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) iL[12]); + iL[16] = 1; + iL[1] = (iL[19] + 1); + iL[4] = iL[1]; + iL[1] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(9, iL[1]); + iL[19] = (iL[1] != 0 ? 0 : iL[4]); + iL[13] = (iL[13] + iL[1]); + break label_87; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(48, iL[1]) != 0) { + break label_87; + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 496, (int) (memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 496) | 1)); + iL[18] = 1116; + } + label_92: { + label_93: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_93; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_92; + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) iL[0]); + long[] callResult_21 = instance.getMachine().call(1880, callArgs_21); + iL[1] = ((int) callResult_21[0]); + } + iL[12] = (iL[1] + -48); + iL[11] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(46, iL[1]); + if (iL[11] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_86; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[12], 10) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_86; + } + break; + } + } + lL[0] = (iL[17] != 0 ? lL[0] : lL[1]); + label_94: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[16]) != 0) { + break label_94; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(69, (iL[1] & -33)) != 0) { + break label_94; + } + label_95: { + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) iL[2]); + callArgs_22[0] = ((long) iL[0]); + long[] callResult_22 = instance.getMachine().call(1885, callArgs_22); + lL[2] = callResult_22[0]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(-9223372036854775808L, lL[2]) != 0) { + break label_95; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_81; + } + lL[2] = 0L; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(memory.readLong((int) iL[0] < 0 ? iL[0] : iL[0] + 88), 0L) != 0) { + break label_95; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + lL[0] = (lL[2] + lL[0]); + break label_80; + } + iL[11] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[16]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[1], 0) != 0) { + break label_82; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(memory.readLong((int) iL[0] < 0 ? iL[0] : iL[0] + 88), 0L) != 0) { + break label_82; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[11]) != 0) { + break label_80; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 28); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = 0L; + callArgs_23[0] = ((long) iL[0]); + instance.getMachine().call(1879, callArgs_23); + dL[0] = 0.0; + break label_1; + } + long[] callArgs_24 = new long[2]; + callArgs_24[1] = 0L; + callArgs_24[0] = ((long) iL[0]); + instance.getMachine().call(1879, callArgs_24); + dL[0] = 0.0; + break label_1; + } + label_96: { + iL[0] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0); + if (iL[0] != 0) { + break label_96; + } + dL[0] = (com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(iL[10]) * 0.0); + break label_1; + } + label_97: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_S(lL[1], 9L) != 0) { + break label_97; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(lL[1], lL[0]) != 0) { + break label_97; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, (iL[8] | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[0] >>> iL[7])))) != 0) { + break label_97; + } + dL[0] = (com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(iL[10]) * com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_U(iL[0])); + break label_1; + } + label_98: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_S(lL[0], com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((iL[14] >>> 1))) != 0) { + break label_98; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 68); + dL[0] = ((com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(iL[10]) * 1.7976931348623157E308) * 1.7976931348623157E308); + break label_1; + } + label_99: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_S(lL[0], (long) (iL[6] + -106)) != 0) { + break label_99; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 68); + dL[0] = ((com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(iL[10]) * 2.2250738585072014E-308) * 2.2250738585072014E-308); + break label_1; + } + label_100: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[19]) != 0) { + break label_100; + } + label_101: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[19], 8) != 0) { + break label_101; + } + iL[11] = (iL[5] + (iL[13] << 2)); + iL[0] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0); + label_102: { + label_103: { + iL[9] = ((1 - iL[19]) & 7); + if (iL[9] != 0) { + break label_103; + } + iL[1] = iL[19]; + break label_102; + } + iL[1] = iL[19]; + label_104: while (true) { + iL[1] = (iL[1] + 1); + iL[0] = (iL[0] * 10); + iL[9] = (iL[9] + -1); + if (iL[9] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_104; + } + break; + } + } + label_105: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((iL[19] + -2), 7) != 0) { + break label_105; + } + iL[1] = (iL[1] + -9); + label_106: while (true) { + iL[0] = (iL[0] * 100000000); + iL[1] = (iL[1] + 8); + if (iL[1] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_106; + } + break; + } + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) iL[0]); + } + iL[13] = (iL[13] + 1); + } + iL[17] = (int) lL[0]; + label_107: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[18], 9) != 0) { + break label_107; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[18], iL[17]) != 0) { + break label_107; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[17], 17) != 0) { + break label_107; + } + label_108: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(9, iL[17]) != 0) { + break label_108; + } + dL[0] = (com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(iL[10]) * com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_U(memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0))); + break label_1; + } + label_109: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[17], 8) != 0) { + break label_109; + } + dL[0] = ((com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(iL[10]) * com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_U(memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0))) / com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(memory.readInt((int) (((8 - iL[17]) << 2) + 62128) < 0 ? (((8 - iL[17]) << 2) + 62128) : (((8 - iL[17]) << 2) + 62128) + 0))); + break label_1; + } + iL[0] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0); + label_110: { + iL[1] = ((iL[7] + (iL[17] * -3)) + 27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[1], 30) != 0) { + break label_110; + } + if ((iL[0] >>> iL[1]) != 0) { + break label_107; + } + } + dL[0] = ((com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(iL[10]) * com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_U(iL[0])) * com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(memory.readInt((int) ((iL[17] << 2) + 62088) < 0 ? ((iL[17] << 2) + 62088) : ((iL[17] << 2) + 62088) + 0))); + break label_1; + } + iL[1] = (iL[13] + 1); + iL[0] = (((iL[13] << 2) + iL[5]) + 4); + label_111: while (true) { + iL[1] = (iL[1] + -1); + iL[9] = (iL[0] + -8); + iL[12] = (iL[0] + -4); + iL[0] = iL[12]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_111; + } + break; + } + iL[2] = 0; + label_112: { + label_113: { + iL[0] = com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_S(iL[17], 9); + if (iL[0] != 0) { + break label_113; + } + iL[9] = 0; + break label_112; + } + iL[9] = 0; + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[17], 0) != 0 ? (iL[0] + 9) : iL[0]); + label_114: { + label_115: { + if (iL[1] != 0) { + break label_115; + } + iL[1] = 0; + break label_114; + } + iL[8] = memory.readInt((int) (((8 - iL[20]) << 2) + 62128) < 0 ? (((8 - iL[20]) << 2) + 62128) : (((8 - iL[20]) << 2) + 62128) + 0); + iL[16] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S(1000000000, iL[8]); + iL[13] = 0; + iL[0] = iL[5]; + iL[11] = 0; + iL[9] = 0; + label_116: while (true) { + iL[19] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[18] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[19], iL[8]); + iL[13] = (iL[18] + iL[13]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) iL[13]); + iL[13] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[9], iL[11]) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13])); + iL[9] = (iL[13] != 0 ? ((iL[9] + 1) & 127) : iL[9]); + iL[17] = (iL[13] != 0 ? (iL[17] + -9) : iL[17]); + iL[0] = (iL[0] + 4); + iL[13] = ((iL[19] - (iL[18] * iL[8])) * iL[16]); + iL[11] = (iL[11] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[1]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_116; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_114; + } + memory.writeI32((int) iL[12] < 0 ? iL[12] : iL[12] + 0, (int) iL[13]); + iL[1] = (iL[1] + 1); + } + iL[17] = ((iL[17] - iL[20]) + 9); + } + label_117: while (true) { + iL[8] = (iL[5] + (iL[9] << 2)); + label_118: { + label_119: while (true) { + label_120: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[17], 18) != 0) { + break label_120; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(18, iL[17]) != 0) { + break label_118; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0), 9007198) != 0) { + break label_118; + } + } + iL[13] = (iL[1] + 127); + iL[11] = 0; + iL[12] = iL[1]; + label_121: while (true) { + iL[1] = iL[12]; + label_122: { + label_123: { + iL[0] = (iL[13] & 127); + iL[12] = (iL[5] + (iL[0] << 2)); + lL[0] = ((((long) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) & 0xFFFFFFFFL) << 29L) + com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(iL[11])); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(lL[0], 1000000001L) != 0) { + break label_123; + } + iL[11] = 0; + break label_122; + } + lL[1] = com.dylibso.chicory.runtime.OpcodeImpl.I64_DIV_U(lL[0], 1000000000L); + lL[0] = (lL[0] - (lL[1] * 1000000000L)); + iL[11] = (int) lL[1]; + } + iL[13] = (int) lL[0]; + memory.writeI32((int) iL[12] < 0 ? iL[12] : iL[12] + 0, (int) iL[13]); + iL[12] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((iL[1] + -1) & 127), iL[0]) != 0 ? iL[1] : (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[9], iL[0]) != 0 ? iL[1] : (iL[13] != 0 ? iL[1] : iL[0]))); + iL[13] = (iL[0] + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[9], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_121; + } + break; + } + iL[2] = (iL[2] + -29); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[11]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_119; + } + break; + } + label_124: { + iL[9] = ((iL[9] + -1) & 127); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[12], iL[9]) != 0) { + break label_124; + } + iL[0] = (iL[5] + (((iL[12] + 126) & 127) << 2)); + iL[1] = ((iL[12] + -1) & 127); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) | memory.readInt((int) (iL[5] + (iL[1] << 2)) < 0 ? (iL[5] + (iL[1] << 2)) : (iL[5] + (iL[1] << 2)) + 0))); + } + iL[17] = (iL[17] + 9); + memory.writeI32((int) (iL[5] + (iL[9] << 2)) < 0 ? (iL[5] + (iL[9] << 2)) : (iL[5] + (iL[9] << 2)) + 0, (int) iL[11]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_117; + } + break; + } + label_125: { + label_126: while (true) { + iL[20] = (iL[5] + ((iL[1] & 127) << 2)); + iL[18] = (iL[5] + (((iL[1] + -1) & 127) << 2)); + iL[16] = ((iL[1] + 1) & 127); + iL[14] = (iL[5] + (iL[16] << 2)); + label_127: { + label_128: while (true) { + label_129: { + label_130: { + iL[0] = (iL[9] & 127); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1], iL[0]) != 0) { + break label_130; + } + label_131: { + iL[0] = memory.readInt((int) (iL[5] + (iL[0] << 2)) < 0 ? (iL[5] + (iL[0] << 2)) : (iL[5] + (iL[0] << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 9007199) != 0) { + break label_131; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(9007199, iL[0]) != 0) { + break label_129; + } + iL[11] = ((iL[9] + 1) & 127); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1], iL[11]) != 0) { + break label_131; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(memory.readInt((int) (iL[5] + (iL[11] << 2)) < 0 ? (iL[5] + (iL[11] << 2)) : (iL[5] + (iL[11] << 2)) + 0), 254740991) != 0) { + break label_129; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(18, iL[17]) != 0) { + break label_129; + } + iL[0] = 9007199; + iL[11] = iL[1]; + break label_125; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(18, iL[17]) != 0) { + break label_129; + } + iL[11] = iL[1]; + break label_125; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(18, iL[17]) != 0) { + break label_127; + } + } + iL[13] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[17], 27) != 0 ? 9 : 1); + label_132: { + label_133: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1], iL[9]) != 0) { + break label_133; + } + iL[2] = (iL[13] + iL[2]); + iL[8] = (1000000000 >>> iL[13]); + iL[19] = ((-1 << iL[13]) ^ -1); + iL[11] = 0; + iL[0] = iL[9]; + label_134: while (true) { + iL[12] = (iL[5] + (iL[0] << 2)); + iL[3] = iL[12]; + iL[12] = memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0); + iL[11] = ((iL[12] >>> iL[13]) + iL[11]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (int) iL[11]); + iL[11] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[9], iL[0]) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[11])); + iL[9] = (iL[11] != 0 ? ((iL[9] + 1) & 127) : iL[9]); + iL[17] = (iL[11] != 0 ? (iL[17] + -9) : iL[17]); + iL[11] = ((iL[12] & iL[19]) * iL[8]); + iL[0] = ((iL[0] + 1) & 127); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[1], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_134; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[11]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_128; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[9], iL[16]) != 0) { + break label_132; + } + memory.writeI32((int) (iL[5] + (iL[1] << 2)) < 0 ? (iL[5] + (iL[1] << 2)) : (iL[5] + (iL[1] << 2)) + 0, (int) iL[11]); + iL[1] = iL[16]; + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_126; + } + iL[11] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[17], 27) != 0 ? 9 : 1); + iL[2] = (iL[13] + iL[2]); + iL[9] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1], 128); + iL[12] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(18, iL[17]); + iL[13] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1], iL[16]); + label_135: while (true) { + label_136: { + label_137: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + break label_137; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[12]) != 0) { + break label_136; + } + iL[9] = iL[1]; + break label_127; + } + label_138: { + label_139: { + iL[0] = memory.readInt((int) iL[20] < 0 ? iL[20] : iL[20] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 9007199) != 0) { + break label_139; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(9007199, iL[0]) != 0) { + break label_136; + } + if (iL[13] != 0) { + break label_139; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0), 254740991) != 0) { + break label_136; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[12]) != 0) { + break label_136; + } + iL[0] = 9007199; + break label_138; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[12]) != 0) { + break label_136; + } + } + iL[9] = iL[1]; + iL[11] = iL[1]; + break label_125; + } + iL[2] = (iL[2] + iL[11]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_135; + } + } + memory.writeI32((int) iL[18] < 0 ? iL[18] : iL[18] + 0, (int) (memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0) | 1)); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_128; + } + } + break; + } + iL[11] = ((iL[1] + 1) & 127); + memory.writeI32((int) (((iL[11] << 2) + iL[5]) + -4) < 0 ? (((iL[11] << 2) + iL[5]) + -4) : (((iL[11] << 2) + iL[5]) + -4) + 0, (int) 0); + iL[0] = memory.readInt((int) (iL[5] + (iL[1] << 2)) < 0 ? (iL[5] + (iL[1] << 2)) : (iL[5] + (iL[1] << 2)) + 0); + } + dL[0] = com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_U(iL[0]); + label_140: { + iL[0] = ((iL[9] + 1) & 127); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[0]) != 0) { + break label_140; + } + iL[11] = ((iL[9] + 2) & 127); + memory.writeI32((int) (((iL[11] << 2) + iL[5]) + -4) < 0 ? (((iL[11] << 2) + iL[5]) + -4) : (((iL[11] << 2) + iL[5]) + -4) + 0, (int) 0); + } + dL[1] = com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(iL[10]); + dL[2] = (((dL[0] * 1.0E9) + com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_U(memory.readInt((int) (iL[5] + (iL[0] << 2)) < 0 ? (iL[5] + (iL[0] << 2)) : (iL[5] + (iL[0] << 2)) + 0))) * dL[1]); + dL[0] = 0.0; + label_141: { + label_142: { + iL[12] = (iL[2] + 53); + iL[0] = (iL[12] - iL[6]); + iL[13] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[0], iL[7]); + iL[1] = (iL[13] != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[0], 0) != 0 ? iL[0] : 0) : iL[7]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[1], 52) != 0) { + break label_142; + } + dL[3] = 0.0; + break label_141; + } + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) (105 - iL[1])); + callArgs_25[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(1.0); + long[] callResult_25 = instance.getMachine().call(1881, callArgs_25); + dL[3] = com.dylibso.chicory.runtime.OpcodeImpl.F64_COPYSIGN(com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_25[0]), dL[2]); + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) (53 - iL[1])); + callArgs_26[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(1.0); + long[] callResult_26 = instance.getMachine().call(1881, callArgs_26); + long[] callArgs_27 = new long[2]; + callArgs_27[1] = com.dylibso.chicory.wasm.types.Value.doubleToLong(com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_26[0])); + callArgs_27[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(dL[2]); + long[] callResult_27 = instance.getMachine().call(1882, callArgs_27); + dL[0] = com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_27[0]); + dL[2] = (dL[3] + (dL[2] - dL[0])); + } + label_143: { + iL[17] = ((iL[9] + 2) & 127); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[11], iL[17]) != 0) { + break label_143; + } + label_144: { + label_145: { + iL[17] = memory.readInt((int) (iL[5] + (iL[17] << 2)) < 0 ? (iL[5] + (iL[17] << 2)) : (iL[5] + (iL[17] << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[17], 499999999) != 0) { + break label_145; + } + label_146: { + if (iL[17] != 0) { + break label_146; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[11], ((iL[9] + 3) & 127)) != 0) { + break label_144; + } + } + dL[0] = ((dL[1] * 0.25) + dL[0]); + break label_144; + } + label_147: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(500000000, iL[17]) != 0) { + break label_147; + } + dL[0] = ((dL[1] * 0.75) + dL[0]); + break label_144; + } + label_148: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], ((iL[9] + 3) & 127)) != 0) { + break label_148; + } + dL[0] = ((dL[1] * 0.5) + dL[0]); + break label_144; + } + dL[0] = ((dL[1] * 0.75) + dL[0]); + } + long[] callArgs_28 = new long[2]; + callArgs_28[1] = com.dylibso.chicory.wasm.types.Value.doubleToLong(1.0); + callArgs_28[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(dL[0]); + long[] callResult_28 = instance.getMachine().call(1882, callArgs_28); + dL[0] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[1], 51) != 0 ? dL[0] : (com.dylibso.chicory.runtime.OpcodeImpl.F64_NE(com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_28[0]), 0.0) != 0 ? dL[0] : (dL[0] + 1.0))); + } + dL[2] = ((dL[2] + dL[0]) - dL[3]); + label_149: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S((iL[12] & 2147483647), (iL[15] + -2)) != 0) { + break label_149; + } + iL[9] = com.dylibso.chicory.runtime.OpcodeImpl.F64_GE(com.dylibso.chicory.runtime.OpcodeImpl.F64_ABS(dL[2]), 9.007199254740992E15); + dL[2] = (iL[9] != 0 ? (dL[2] * 0.5) : dL[2]); + label_150: { + iL[2] = (iL[2] + iL[9]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((iL[2] + 50), iL[15]) != 0) { + break label_150; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((iL[9] != 0 ? (iL[13] & com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[0], iL[1])) : iL[13]) & com.dylibso.chicory.runtime.OpcodeImpl.F64_NE(dL[0], 0.0))) != 0) { + break label_149; + } + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 68); + } + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) iL[2]); + callArgs_29[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(dL[2]); + long[] callResult_29 = instance.getMachine().call(1881, callArgs_29); + dL[0] = com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_29[0]); + } + instance.global(0).setValue(((long) (iL[5] + 512))); + return dL[0]; + } + + public static long[] call_1883(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + double result = Wat2WasmMachine.func_1883(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(result); + return out; + } + + public static double func_1884(int arg0, int arg1, int arg2, int arg3, int arg4, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local5 = 0; + long local6 = 0L; + int local7 = 0; + int local8 = 0; + int local9 = 0; + long local10 = 0L; + double local11 = 0.0; + double local12 = 0.0; + int local13 = 0; + int local14 = 0; + int local15 = 0; + long local16 = 0L; + long local17 = 0L; + double local18 = 0.0; + label_1: { + label_2: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local5) != 0) { + break label_2; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local5 + 1)); + local5 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1880, callArgs_0); + local5 = ((int) callResult_0[0]); + } + local6 = 0L; + local7 = 0; + local8 = 0; + local9 = 0; + local10 = 0L; + label_3: { + label_4: { + label_5: { + switch((local5 + -46)) { + case 0: + { + break label_4; + } + case 1: + { + break label_3; + } + case 2: + { + break label_5; + } + default: + { + break label_3; + } + } + } + label_6: { + label_7: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local5) != 0) { + break label_7; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local5 + 1)); + local5 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + break label_6; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1880, callArgs_1); + local5 = ((int) callResult_1[0]); + } + label_8: { + label_9: while (true) { + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(48, local5) != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(46, local5) != 0) { + break label_8; + } + local7 = 1; + break label_4; + } + label_11: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local5) != 0) { + break label_11; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local5 + 1)); + local5 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1880, callArgs_2); + local5 = ((int) callResult_2[0]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + } + local9 = 1; + local8 = 0; + local10 = 0L; + break label_3; + } + label_12: { + label_13: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local5) != 0) { + break label_13; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local5 + 1)); + local5 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + break label_12; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1880, callArgs_3); + local5 = ((int) callResult_3[0]); + } + local8 = 1; + local9 = local7; + local10 = 0L; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(48, local5) != 0) { + break label_3; + } + local10 = 0L; + label_14: while (true) { + label_15: { + label_16: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local5) != 0) { + break label_16; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local5 + 1)); + local5 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + break label_15; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1880, callArgs_4); + local5 = ((int) callResult_4[0]); + } + local10 = (local10 + -1L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(48, local5) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + local8 = 1; + local9 = 1; + } + local11 = 1.0; + local12 = 0.0; + local13 = 0; + local14 = 0; + label_17: { + label_18: while (true) { + local7 = (local5 | 32); + label_19: { + label_20: { + local15 = (local5 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local15, 10) != 0) { + break label_20; + } + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((local7 + -97), 6) != 0) { + break label_21; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(46, local5) != 0) { + break label_17; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(46, local5) != 0) { + break label_20; + } + if (local8 != 0) { + break label_17; + } + local8 = 1; + local10 = local6; + break label_19; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local5, 57) != 0 ? (local7 + -87) : local15); + label_22: { + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_S(local6, 7L) != 0) { + break label_23; + } + local13 = (local5 + (local13 << 4)); + break label_22; + } + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(local6, 13L) != 0) { + break label_24; + } + local11 = (local11 * 0.0625); + local12 = ((com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(local5) * local11) + local12); + break label_22; + } + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) | com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local14)); + local12 = (local5 != 0 ? local12 : ((local11 * 0.5) + local12)); + local14 = (local5 != 0 ? local14 : 1); + } + local6 = (local6 + 1L); + local9 = 1; + } + label_25: { + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local5) != 0) { + break label_25; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local5 + 1)); + local5 = ((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) arg0); + long[] callResult_5 = instance.getMachine().call(1880, callArgs_5); + local5 = ((int) callResult_5[0]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + } + label_26: { + if (local9 != 0) { + break label_26; + } + label_27: { + label_28: { + label_29: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 88), 0L) != 0) { + break label_29; + } + local5 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local5 + -1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_28; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local5 + -2)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local8) != 0) { + break label_27; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local5 + -3)); + break label_27; + } + if (arg4 != 0) { + break label_27; + } + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = 0L; + callArgs_6[0] = ((long) arg0); + instance.getMachine().call(1879, callArgs_6); + } + return (com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(arg3) * 0.0); + } + label_30: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_S(local6, 7L) != 0) { + break label_30; + } + label_31: { + label_32: { + local16 = ((0L - local6) & 7L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(local16)) != 0) { + break label_32; + } + local17 = local6; + break label_31; + } + local17 = local6; + label_33: while (true) { + local17 = (local17 + 1L); + local13 = (local13 << 4); + local16 = (local16 + -1L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(0L, local16) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_33; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U((local6 + -1L), 7L) != 0) { + break label_30; + } + local17 = (local17 + -8L); + label_34: while (true) { + local17 = (local17 + 8L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(0L, local17) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_34; + } + break; + } + local13 = 0; + } + label_35: { + label_36: { + label_37: { + label_38: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(80, (local5 & -33)) != 0) { + break label_38; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) arg4); + callArgs_7[0] = ((long) arg0); + long[] callResult_7 = instance.getMachine().call(1885, callArgs_7); + local17 = callResult_7[0]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(-9223372036854775808L, local17) != 0) { + break label_35; + } + label_39: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg4) != 0) { + break label_39; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_S(memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 88), -1L) != 0) { + break label_37; + } + break label_36; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = 0L; + callArgs_8[0] = ((long) arg0); + instance.getMachine().call(1879, callArgs_8); + return 0.0; + } + local17 = 0L; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 88), 0L) != 0) { + break label_35; + } + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + -1)); + } + local17 = 0L; + } + label_40: { + if (local13 != 0) { + break label_40; + } + return (com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(arg3) * 0.0); + } + label_41: { + local6 = ((((local8 != 0 ? local10 : local6) << 2L) + local17) + -32L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LE_S(local6, com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((0 - arg2))) != 0) { + break label_41; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 68); + return ((com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(arg3) * 1.7976931348623157E308) * 1.7976931348623157E308); + } + label_42: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(local6, (long) (arg2 + -106)) != 0) { + break label_42; + } + label_43: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local13, 0) != 0) { + break label_43; + } + label_44: while (true) { + local5 = com.dylibso.chicory.runtime.OpcodeImpl.F64_GE(local12, 0.5); + local12 = (local12 + (local5 != 0 ? (local12 + -1.0) : local12)); + local6 = (local6 + -1L); + local13 = (local5 | (local13 << 1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local13, -1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_44; + } + break; + } + } + label_45: { + label_46: { + local10 = ((local6 - (long) arg2) + 32L); + local5 = (int) local10; + local5 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(local10, com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(arg1)) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(local5, 0) != 0 ? local5 : 0) : arg1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, 53) != 0) { + break label_46; + } + local11 = com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(arg3); + local18 = 0.0; + break label_45; + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) (84 - local5)); + callArgs_9[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(1.0); + long[] callResult_9 = instance.getMachine().call(1881, callArgs_9); + local11 = com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(arg3); + local18 = com.dylibso.chicory.runtime.OpcodeImpl.F64_COPYSIGN(com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_9[0]), local11); + } + label_47: { + local5 = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local5, 32) & com.dylibso.chicory.runtime.OpcodeImpl.F64_NE(local12, 0.0)) & com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local13 & 1))); + local12 = (((local11 * (local5 != 0 ? 0.0 : local12)) + ((local11 * com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_U((local13 + local5))) + local18)) - local18); + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_NE(local12, 0.0) != 0) { + break label_47; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 68); + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) (int) local6); + callArgs_10[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(local12); + long[] callResult_10 = instance.getMachine().call(1881, callArgs_10); + return com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_10[0]); + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 68); + return ((com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_S(arg3) * 2.2250738585072014E-308) * 2.2250738585072014E-308); + } + + public static long[] call_1884(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int arg3 = ((int) args[3]); + int arg4 = ((int) args[4]); + double result = Wat2WasmMachine.func_1884(arg0, arg1, arg2, arg3, arg4, memory, instance); + long[] out = new long[1]; + out[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(result); + return out; + } + + public static long func_1885(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + label_1: { + label_2: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local2) != 0) { + break label_2; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + 1)); + local3 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF); + break label_1; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1880, callArgs_0); + local3 = ((int) callResult_0[0]); + } + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + switch((local3 + -43)) { + case 0: + { + break label_7; + } + case 1: + { + break label_6; + } + case 2: + { + break label_7; + } + default: + { + break label_6; + } + } + } + label_8: { + label_9: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local2) != 0) { + break label_9; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + 1)); + local2 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF); + break label_8; + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) arg0); + long[] callResult_1 = instance.getMachine().call(1880, callArgs_1); + local2 = ((int) callResult_1[0]); + } + local4 = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(45, local3); + local5 = (local2 + -58); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, -11) != 0) { + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 88), 0L) != 0) { + break label_4; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + -1)); + break label_4; + } + local5 = (local3 + -58); + local4 = 0; + local2 = local3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, -10) != 0) { + break label_4; + } + local6 = 0L; + label_10: { + local5 = (local2 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 9) != 0) { + break label_10; + } + local3 = 0; + label_11: while (true) { + local3 = (local2 + (local3 * 10)); + label_12: { + label_13: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local2) != 0) { + break label_13; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + 1)); + local2 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF); + break label_12; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) arg0); + long[] callResult_2 = instance.getMachine().call(1880, callArgs_2); + local2 = ((int) callResult_2[0]); + } + local3 = (local3 + -48); + label_14: { + local5 = (local2 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 9) != 0) { + break label_14; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(local3, 214748364) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + } + break; + } + local6 = (long) local3; + } + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 9) != 0) { + break label_15; + } + label_16: while (true) { + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local2) + (local6 * 10L)); + label_17: { + label_18: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local2) != 0) { + break label_18; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + 1)); + local2 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF); + break label_17; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) arg0); + long[] callResult_3 = instance.getMachine().call(1880, callArgs_3); + local2 = ((int) callResult_3[0]); + } + local6 = (local6 + -48L); + local5 = (local2 + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 9) != 0) { + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(local6, 92233720368547758L) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_16; + } + break; + } + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 9) != 0) { + break label_19; + } + label_20: while (true) { + label_21: { + label_22: { + local2 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 84), local2) != 0) { + break label_22; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (local2 + 1)); + local2 = ((int) memory.read((int) local2 < 0 ? local2 : local2 + 0) & 0xFF); + break label_21; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) arg0); + long[] callResult_4 = instance.getMachine().call(1880, callArgs_4); + local2 = ((int) callResult_4[0]); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((local2 + -48), 10) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + } + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 88), 0L) != 0) { + break label_23; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + -1)); + } + local6 = (local4 != 0 ? (0L - local6) : local6); + break label_3; + } + local6 = -9223372036854775808L; + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(memory.readLong((int) arg0 < 0 ? arg0 : arg0 + 88), 0L) != 0) { + break label_3; + } + memory.writeI32((int) arg0 < 0 ? arg0 : arg0 + 4, (int) (memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 4) + -1)); + return -9223372036854775808L; + } + return local6; + } + + public static long[] call_1885(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + long result = Wat2WasmMachine.func_1885(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = result; + return out; + } + + public static float func_1886(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + double local3 = 0.0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) arg0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) arg0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) -1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = 0L; + callArgs_0[0] = ((long) local2); + instance.getMachine().call(1879, callArgs_0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 1); + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(1883, callArgs_1); + local3 = com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_1[0]); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) (arg0 + ((memory.readInt((int) local2 < 0 ? local2 : local2 + 4) + memory.readInt((int) local2 < 0 ? local2 : local2 + 96)) - memory.readInt((int) local2 < 0 ? local2 : local2 + 40)))); + } + instance.global(0).setValue(((long) (local2 + 112))); + return (float) local3; + } + + public static long[] call_1886(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + float result = Wat2WasmMachine.func_1886(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = com.dylibso.chicory.wasm.types.Value.floatToLong(result); + return out; + } + + public static double func_1887(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + double local3 = 0.0; + local2 = (((int) instance.global(0).getValue()) - 112); + instance.global(0).setValue(((long) local2)); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 40, (int) arg0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 4, (int) arg0); + memory.writeI32((int) local2 < 0 ? local2 : local2 + 8, (int) -1); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = 0L; + callArgs_0[0] = ((long) local2); + instance.getMachine().call(1879, callArgs_0); + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) 1); + callArgs_1[1] = ((long) 1); + callArgs_1[0] = ((long) local2); + long[] callResult_1 = instance.getMachine().call(1883, callArgs_1); + local3 = com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_1[0]); + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg1) != 0) { + break label_1; + } + memory.writeI32((int) arg1 < 0 ? arg1 : arg1 + 0, (int) (arg0 + ((memory.readInt((int) local2 < 0 ? local2 : local2 + 4) + memory.readInt((int) local2 < 0 ? local2 : local2 + 96)) - memory.readInt((int) local2 < 0 ? local2 : local2 + 40)))); + } + instance.global(0).setValue(((long) (local2 + 112))); + return local3; + } + + public static long[] call_1887(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + double result = Wat2WasmMachine.func_1887(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(result); + return out; + } + + public static int func_1888(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, arg2); + label_1: { + label_2: { + label_3: { + label_4: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg0 & 3)) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_4; + } + label_5: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((arg1 & 255), ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_5; + } + local4 = arg0; + local5 = arg2; + break label_2; + } + local5 = (arg2 + -1); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5); + local4 = (arg0 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local4 & 3)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((arg1 & 255), ((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_2; + } + local5 = (arg2 + -2); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5); + local4 = (arg0 + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local4 & 3)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((arg1 & 255), ((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_2; + } + local5 = (arg2 + -3); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5); + local4 = (arg0 + 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local4 & 3)) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((arg1 & 255), ((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_2; + } + local4 = (arg0 + 4); + local5 = (arg2 + -4); + local3 = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, local5); + break label_3; + } + local5 = arg2; + local4 = arg0; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((arg1 & 255), ((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_6; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 4) != 0) { + break label_6; + } + arg0 = ((arg1 & 255) * 16843009); + label_7: while (true) { + arg2 = (memory.readInt((int) local4 < 0 ? local4 : local4 + 0) ^ arg0); + if ((((arg2 ^ -1) & (arg2 + -16843009)) & -2139062144) != 0) { + break label_2; + } + local4 = (local4 + 4); + local5 = (local5 + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_7; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + } + arg2 = (arg1 & 255); + label_8: while (true) { + label_9: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(arg2, ((int) memory.read((int) local4 < 0 ? local4 : local4 + 0) & 0xFF)) != 0) { + break label_9; + } + return local4; + } + local4 = (local4 + 1); + local5 = (local5 + -1); + if (local5 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_8; + } + break; + } + } + return 0; + } + + public static long[] call_1888(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1888(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1889(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + local3 = 0; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + label_2: { + label_3: while (true) { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + local5 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(local5, local4) != 0) { + break label_2; + } + arg1 = (arg1 + 1); + arg0 = (arg0 + 1); + arg2 = (arg2 + -1); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break label_1; + } + } + local3 = (local4 - local5); + } + return local3; + } + + public static long[] call_1889(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1889(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1890(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 32) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg1 & 3)) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF))); + local3 = (arg2 + -1); + local4 = (arg0 + 1); + local5 = (arg1 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local5 & 3)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 1, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 1) & 0xFF))); + local3 = (arg2 + -2); + local4 = (arg0 + 2); + local5 = (arg1 + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local5 & 3)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 2, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 2) & 0xFF))); + local3 = (arg2 + -3); + local4 = (arg0 + 3); + local5 = (arg1 + 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local5 & 3)) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 3) & 0xFF))); + local3 = (arg2 + -4); + local4 = (arg0 + 4); + local5 = (arg1 + 4); + break label_1; + } + memory.copy(arg0, arg1, arg2); + return arg0; + } + local3 = arg2; + local4 = arg0; + local5 = arg1; + } + label_4: { + label_5: { + arg2 = (local4 & 3); + if (arg2 != 0) { + break label_5; + } + label_6: { + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 16) != 0) { + break label_7; + } + arg2 = local3; + break label_6; + } + label_8: { + arg2 = (local3 + -16); + if ((arg2 & 16) != 0) { + break label_8; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 8)); + local4 = (local4 + 16); + local5 = (local5 + 16); + local3 = arg2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 16) != 0) { + break label_6; + } + arg2 = local3; + label_9: while (true) { + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 8, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 8)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 16, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 16)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 24, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 24)); + local4 = (local4 + 32); + local5 = (local5 + 32); + arg2 = (arg2 + -32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 15) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_9; + } + break; + } + } + label_10: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 8) != 0) { + break label_10; + } + memory.writeLong((int) local4 < 0 ? local4 : local4 + 0, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 0)); + local5 = (local5 + 8); + local4 = (local4 + 8); + } + label_11: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg2 & 4)) != 0) { + break label_11; + } + memory.writeI32((int) local4 < 0 ? local4 : local4 + 0, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 0)); + local5 = (local5 + 4); + local4 = (local4 + 4); + } + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg2 & 2)) != 0) { + break label_12; + } + memory.writeShort((int) local4 < 0 ? local4 : local4 + 0, (short) (((int) memory.readShort((int) local5 < 0 ? local5 : local5 + 0) & 0xFFFF))); + local4 = (local4 + 2); + local5 = (local5 + 2); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg2 & 1)) != 0) { + break label_4; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF))); + return arg0; + } + label_13: { + label_14: { + label_15: { + label_16: { + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local3, 32) != 0) { + break label_17; + } + label_18: { + label_19: { + switch((arg2 + -1)) { + case 0: + { + break label_16; + } + case 1: + { + break label_19; + } + case 2: + { + break label_18; + } + default: + { + break label_4; + } + } + } + memory.writeShort((int) local4 < 0 ? local4 : local4 + 0, (short) (memory.readInt((int) local5 < 0 ? local5 : local5 + 0))); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 2, (int) memory.readInt((int) (local5 + 2) < 0 ? (local5 + 2) : (local5 + 2) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 6, (long) memory.readLong((int) (local5 + 6) < 0 ? (local5 + 6) : (local5 + 6) + 0)); + arg2 = (local4 + 18); + arg1 = (local5 + 18); + local6 = 14; + local5 = memory.readInt((int) (local5 + 14) < 0 ? (local5 + 14) : (local5 + 14) + 0); + local3 = 14; + break label_15; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (memory.readInt((int) local5 < 0 ? local5 : local5 + 0))); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 1, (int) memory.readInt((int) (local5 + 1) < 0 ? (local5 + 1) : (local5 + 1) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 5, (long) memory.readLong((int) (local5 + 5) < 0 ? (local5 + 5) : (local5 + 5) + 0)); + arg2 = (local4 + 17); + arg1 = (local5 + 17); + local6 = 13; + local5 = memory.readInt((int) (local5 + 13) < 0 ? (local5 + 13) : (local5 + 13) + 0); + local3 = 15; + break label_15; + } + label_20: { + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(local3, 16) != 0) { + break label_21; + } + arg2 = local4; + arg1 = local5; + break label_20; + } + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (((int) memory.read((int) local5 < 0 ? local5 : local5 + 0) & 0xFF))); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 1, (int) memory.readInt((int) local5 < 0 ? local5 : local5 + 1)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 5, (long) memory.readLong((int) local5 < 0 ? local5 : local5 + 5)); + memory.writeShort((int) local4 < 0 ? local4 : local4 + 13, (short) (((int) memory.readShort((int) local5 < 0 ? local5 : local5 + 13) & 0xFFFF))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 15, (byte) (((int) memory.read((int) local5 < 0 ? local5 : local5 + 15) & 0xFF))); + arg2 = (local4 + 16); + arg1 = (local5 + 16); + } + if ((local3 & 8) != 0) { + break label_14; + } + break label_13; + } + arg2 = memory.readInt((int) local5 < 0 ? local5 : local5 + 0); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (arg2)); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 2, (byte) ((arg2 >>> 16))); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 1, (byte) ((arg2 >>> 8))); + memory.writeI32((int) local4 < 0 ? local4 : local4 + 3, (int) memory.readInt((int) (local5 + 3) < 0 ? (local5 + 3) : (local5 + 3) + 0)); + memory.writeLong((int) local4 < 0 ? local4 : local4 + 7, (long) memory.readLong((int) (local5 + 7) < 0 ? (local5 + 7) : (local5 + 7) + 0)); + arg2 = (local4 + 19); + arg1 = (local5 + 19); + local6 = 15; + local5 = memory.readInt((int) (local5 + 15) < 0 ? (local5 + 15) : (local5 + 15) + 0); + local3 = 13; + } + memory.writeI32((int) (local4 + local6) < 0 ? (local4 + local6) : (local4 + local6) + 0, (int) local5); + } + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) memory.readLong((int) arg1 < 0 ? arg1 : arg1 + 0)); + arg2 = (arg2 + 8); + arg1 = (arg1 + 8); + } + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local3 & 4)) != 0) { + break label_22; + } + memory.writeI32((int) arg2 < 0 ? arg2 : arg2 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + arg2 = (arg2 + 4); + arg1 = (arg1 + 4); + } + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local3 & 2)) != 0) { + break label_23; + } + memory.writeShort((int) arg2 < 0 ? arg2 : arg2 + 0, (short) (((int) memory.readShort((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFFFF))); + arg2 = (arg2 + 2); + arg1 = (arg1 + 2); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local3 & 1)) != 0) { + break label_4; + } + memory.writeByte((int) arg2 < 0 ? arg2 : arg2 + 0, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF))); + } + return arg0; + } + + public static long[] call_1890(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1890(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1891(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + int local6 = 0; + label_1: { + label_2: { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg2, 33) != 0) { + break label_3; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(arg1, arg0) != 0) { + break label_1; + } + local3 = (arg0 + arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((arg1 - local3), (0 - (arg2 << 1))) != 0) { + break label_2; + } + } + memory.copy(arg0, arg1, arg2); + break label_1; + } + local4 = ((arg1 ^ arg0) & 3); + label_4: { + label_5: { + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(arg0, arg1) != 0) { + break label_6; + } + label_7: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_7; + } + local5 = arg2; + local3 = arg0; + break label_4; + } + label_8: { + if ((arg0 & 3) != 0) { + break label_8; + } + local5 = arg2; + local3 = arg0; + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF))); + local5 = (arg2 + -1); + label_9: { + local3 = (arg0 + 1); + if ((local3 & 3) != 0) { + break label_9; + } + arg1 = (arg1 + 1); + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 1, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 1) & 0xFF))); + local5 = (arg2 + -2); + label_10: { + local3 = (arg0 + 2); + if ((local3 & 3) != 0) { + break label_10; + } + arg1 = (arg1 + 2); + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 2, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 2) & 0xFF))); + local5 = (arg2 + -3); + label_11: { + local3 = (arg0 + 3); + if ((local3 & 3) != 0) { + break label_11; + } + arg1 = (arg1 + 3); + break label_5; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 3) & 0xFF))); + local3 = (arg0 + 4); + arg1 = (arg1 + 4); + local5 = (arg2 + -4); + break label_5; + } + label_12: { + if (local4 != 0) { + break label_12; + } + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local3 & 3)) != 0) { + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + local3 = (arg2 + -1); + local4 = (arg0 + local3); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (((int) memory.read((int) (arg1 + local3) < 0 ? (arg1 + local3) : (arg1 + local3) + 0) & 0xFF))); + label_14: { + if ((local4 & 3) != 0) { + break label_14; + } + arg2 = local3; + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + local3 = (arg2 + -2); + local4 = (arg0 + local3); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (((int) memory.read((int) (arg1 + local3) < 0 ? (arg1 + local3) : (arg1 + local3) + 0) & 0xFF))); + label_15: { + if ((local4 & 3) != 0) { + break label_15; + } + arg2 = local3; + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + local3 = (arg2 + -3); + local4 = (arg0 + local3); + memory.writeByte((int) local4 < 0 ? local4 : local4 + 0, (byte) (((int) memory.read((int) (arg1 + local3) < 0 ? (arg1 + local3) : (arg1 + local3) + 0) & 0xFF))); + label_16: { + if ((local4 & 3) != 0) { + break label_16; + } + arg2 = local3; + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + arg2 = (arg2 + -4); + memory.writeByte((int) (arg0 + arg2) < 0 ? (arg0 + arg2) : (arg0 + arg2) + 0, (byte) (((int) memory.read((int) (arg1 + arg2) < 0 ? (arg1 + arg2) : (arg1 + arg2) + 0) & 0xFF))); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 4) != 0) { + break label_12; + } + label_17: { + local6 = (arg2 + -4); + local3 = (((local6 >>> 2) + 1) & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_17; + } + local4 = (arg1 + -4); + local5 = (arg0 + -4); + label_18: while (true) { + memory.writeI32((int) (local5 + arg2) < 0 ? (local5 + arg2) : (local5 + arg2) + 0, (int) memory.readInt((int) (local4 + arg2) < 0 ? (local4 + arg2) : (local4 + arg2) + 0)); + arg2 = (arg2 + -4); + local3 = (local3 + -1); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local6, 12) != 0) { + break label_12; + } + local5 = (arg1 + -16); + local6 = (arg0 + -16); + label_19: while (true) { + local3 = (local6 + arg2); + local4 = (local5 + arg2); + memory.writeI32((int) (local3 + 12) < 0 ? (local3 + 12) : (local3 + 12) + 0, (int) memory.readInt((int) (local4 + 12) < 0 ? (local4 + 12) : (local4 + 12) + 0)); + memory.writeI32((int) (local3 + 8) < 0 ? (local3 + 8) : (local3 + 8) + 0, (int) memory.readInt((int) (local4 + 8) < 0 ? (local4 + 8) : (local4 + 8) + 0)); + memory.writeI32((int) (local3 + 4) < 0 ? (local3 + 4) : (local3 + 4) + 0, (int) memory.readInt((int) (local4 + 4) < 0 ? (local4 + 4) : (local4 + 4) + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) local4 < 0 ? local4 : local4 + 0)); + arg2 = (arg2 + -16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg2, 3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_19; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_1; + } + local3 = arg2; + label_20: { + local4 = (arg2 & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_20; + } + local5 = (arg1 + -1); + local6 = (arg0 + -1); + local3 = arg2; + label_21: while (true) { + memory.writeByte((int) (local6 + local3) < 0 ? (local6 + local3) : (local6 + local3) + 0, (byte) (((int) memory.read((int) (local5 + local3) < 0 ? (local5 + local3) : (local5 + local3) + 0) & 0xFF))); + local3 = (local3 + -1); + local4 = (local4 + -1); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_21; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 4) != 0) { + break label_1; + } + local4 = (arg1 + -4); + local5 = (arg0 + -4); + label_22: while (true) { + arg1 = (local5 + local3); + arg2 = (local4 + local3); + memory.writeByte((int) (arg1 + 3) < 0 ? (arg1 + 3) : (arg1 + 3) + 0, (byte) (((int) memory.read((int) (arg2 + 3) < 0 ? (arg2 + 3) : (arg2 + 3) + 0) & 0xFF))); + memory.writeByte((int) (arg1 + 2) < 0 ? (arg1 + 2) : (arg1 + 2) + 0, (byte) (((int) memory.read((int) (arg2 + 2) < 0 ? (arg2 + 2) : (arg2 + 2) + 0) & 0xFF))); + memory.writeByte((int) (arg1 + 1) < 0 ? (arg1 + 1) : (arg1 + 1) + 0, (byte) (((int) memory.read((int) (arg2 + 1) < 0 ? (arg2 + 1) : (arg2 + 1) + 0) & 0xFF))); + memory.writeByte((int) arg1 < 0 ? arg1 : arg1 + 0, (byte) (((int) memory.read((int) arg2 < 0 ? arg2 : arg2 + 0) & 0xFF))); + local3 = (local3 + -4); + if (local3 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_22; + } + break label_1; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 4) != 0) { + break label_4; + } + label_23: { + local4 = (local5 + -4); + arg2 = (((local4 >>> 2) + 1) & 7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_23; + } + label_24: while (true) { + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + arg1 = (arg1 + 4); + local3 = (local3 + 4); + local5 = (local5 + -4); + arg2 = (arg2 + -1); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_24; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local4, 28) != 0) { + break label_4; + } + label_25: while (true) { + memory.writeI32((int) local3 < 0 ? local3 : local3 + 0, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 0)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 4, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 4)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 8, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 8)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 12, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 12)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 16, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 16)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 20, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 20)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 24, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 24)); + memory.writeI32((int) local3 < 0 ? local3 : local3 + 28, (int) memory.readInt((int) arg1 < 0 ? arg1 : arg1 + 28)); + arg1 = (arg1 + 32); + local3 = (local3 + 32); + local5 = (local5 + -32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(local5, 3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_25; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local5) != 0) { + break label_1; + } + label_26: { + label_27: { + local4 = (local5 & 7); + if (local4 != 0) { + break label_27; + } + arg2 = local5; + break label_26; + } + arg2 = local5; + label_28: while (true) { + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF))); + arg2 = (arg2 + -1); + local3 = (local3 + 1); + arg1 = (arg1 + 1); + local4 = (local4 + -1); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_28; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(local5, 8) != 0) { + break label_1; + } + label_29: while (true) { + memory.writeByte((int) local3 < 0 ? local3 : local3 + 0, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 1, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 1) & 0xFF))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 2, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 2) & 0xFF))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 3, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 3) & 0xFF))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 4, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 4) & 0xFF))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 5, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 5) & 0xFF))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 6, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 6) & 0xFF))); + memory.writeByte((int) local3 < 0 ? local3 : local3 + 7, (byte) (((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 7) & 0xFF))); + local3 = (local3 + 8); + arg1 = (arg1 + 8); + arg2 = (arg2 + -8); + if (arg2 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_29; + } + break; + } + } + return arg0; + } + + public static long[] call_1891(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1891(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1892(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + long local6 = 0L; + label_1: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 33) != 0) { + break label_1; + } + memory.fill((byte) arg1, arg0, arg2 + arg0); + return arg0; + } + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg2) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 0, (byte) (arg1)); + local3 = (arg2 + arg0); + memory.writeByte((int) (local3 + -1) < 0 ? (local3 + -1) : (local3 + -1) + 0, (byte) (arg1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 3) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 2, (byte) (arg1)); + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 1, (byte) (arg1)); + memory.writeByte((int) (local3 + -3) < 0 ? (local3 + -3) : (local3 + -3) + 0, (byte) (arg1)); + memory.writeByte((int) (local3 + -2) < 0 ? (local3 + -2) : (local3 + -2) + 0, (byte) (arg1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 7) != 0) { + break label_2; + } + memory.writeByte((int) arg0 < 0 ? arg0 : arg0 + 3, (byte) (arg1)); + memory.writeByte((int) (local3 + -4) < 0 ? (local3 + -4) : (local3 + -4) + 0, (byte) (arg1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg2, 9) != 0) { + break label_2; + } + local4 = ((0 - arg0) & 3); + local5 = (arg0 + local4); + local3 = ((arg1 & 255) * 16843009); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 0, (int) local3); + arg1 = ((arg2 - local4) & -4); + arg2 = (local5 + arg1); + memory.writeI32((int) (arg2 + -4) < 0 ? (arg2 + -4) : (arg2 + -4) + 0, (int) local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 9) != 0) { + break label_2; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 8, (int) local3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 4, (int) local3); + memory.writeI32((int) (arg2 + -8) < 0 ? (arg2 + -8) : (arg2 + -8) + 0, (int) local3); + memory.writeI32((int) (arg2 + -12) < 0 ? (arg2 + -12) : (arg2 + -12) + 0, (int) local3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 25) != 0) { + break label_2; + } + memory.writeI32((int) local5 < 0 ? local5 : local5 + 24, (int) local3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 20, (int) local3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 16, (int) local3); + memory.writeI32((int) local5 < 0 ? local5 : local5 + 12, (int) local3); + memory.writeI32((int) (arg2 + -16) < 0 ? (arg2 + -16) : (arg2 + -16) + 0, (int) local3); + memory.writeI32((int) (arg2 + -20) < 0 ? (arg2 + -20) : (arg2 + -20) + 0, (int) local3); + memory.writeI32((int) (arg2 + -24) < 0 ? (arg2 + -24) : (arg2 + -24) + 0, (int) local3); + memory.writeI32((int) (arg2 + -28) < 0 ? (arg2 + -28) : (arg2 + -28) + 0, (int) local3); + arg2 = ((local5 & 4) | 24); + arg1 = (arg1 - arg2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(arg1, 32) != 0) { + break label_2; + } + local6 = (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(local3) * 4294967297L); + arg2 = (local5 + arg2); + label_3: while (true) { + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 24, (long) local6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 16, (long) local6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 8, (long) local6); + memory.writeLong((int) arg2 < 0 ? arg2 : arg2 + 0, (long) local6); + arg2 = (arg2 + 32); + arg1 = (arg1 + -32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(arg1, 31) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + return arg0; + } + + public static long[] call_1892(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1892(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1893(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) arg1); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1894, callArgs_0); + arg0 = ((int) callResult_0[0]); + return (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((arg1 & 255), ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0 ? arg0 : 0); + } + + public static long[] call_1893(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1893(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1894(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + int local4 = 0; + label_1: { + label_2: { + label_3: { + label_4: { + local2 = (arg1 & 255); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_4; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg0 & 3)) != 0) { + break label_2; + } + label_5: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + if (local3 != 0) { + break label_5; + } + return arg0; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((arg1 & 255), local3) != 0) { + break label_3; + } + return arg0; + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + return (arg0 + ((int) callResult_0[0])); + } + label_6: { + local3 = (arg0 + 1); + if ((local3 & 3) != 0) { + break label_6; + } + arg0 = local3; + break label_2; + } + local4 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((arg1 & 255), local4) != 0) { + break label_1; + } + label_7: { + local3 = (arg0 + 2); + if ((local3 & 3) != 0) { + break label_7; + } + arg0 = local3; + break label_2; + } + local4 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((arg1 & 255), local4) != 0) { + break label_1; + } + label_8: { + local3 = (arg0 + 3); + if ((local3 & 3) != 0) { + break label_8; + } + arg0 = local3; + break label_2; + } + local4 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((arg1 & 255), local4) != 0) { + break label_1; + } + arg0 = (arg0 + 4); + } + label_9: { + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if ((((local3 ^ -1) & (local3 + -16843009)) & -2139062144) != 0) { + break label_9; + } + local2 = (local2 * 16843009); + label_10: while (true) { + local3 = (local3 ^ local2); + if ((((local3 ^ -1) & (local3 + -16843009)) & -2139062144) != 0) { + break label_9; + } + arg0 = (arg0 + 4); + local3 = memory.readInt((int) arg0 < 0 ? arg0 : arg0 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((local3 ^ -1) & (local3 + -16843009)) & -2139062144)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_10; + } + break; + } + } + local3 = (arg0 + -1); + label_11: while (true) { + local3 = (local3 + 1); + arg0 = ((int) memory.read((int) local3 < 0 ? local3 : local3 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(arg0) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((arg1 & 255), arg0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + break; + } + } + return local3; + } + + public static long[] call_1894(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1894(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1895(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + int local3 = 0; + local2 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF); + label_1: { + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((local2 & 255), local3) != 0) { + break label_1; + } + arg0 = (arg0 + 1); + arg1 = (arg1 + 1); + label_2: while (true) { + local2 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF); + local3 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local3) != 0) { + break label_1; + } + arg0 = (arg0 + 1); + arg1 = (arg1 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((local2 & 255), local3) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + } + return (local3 - (local2 & 255)); + } + + public static long[] call_1895(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1895(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1896(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + label_1: { + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1897, callArgs_0); + local1 = (((int) callResult_0[0]) + 1); + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) local1); + long[] callResult_1 = instance.getMachine().call(1782, callArgs_1); + local2 = ((int) callResult_1[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local2) != 0) { + break label_1; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) local1); + callArgs_2[1] = ((long) arg0); + callArgs_2[0] = ((long) local2); + long[] callResult_2 = instance.getMachine().call(1890, callArgs_2); + } + return local2; + } + + public static long[] call_1896(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1896(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1897(int arg0, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local1 = 0; + int local2 = 0; + local1 = arg0; + label_1: { + label_2: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((arg0 & 3)) != 0) { + break label_2; + } + local1 = arg0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF)) != 0) { + break label_1; + } + local1 = (arg0 + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local1 & 3)) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local1 < 0 ? local1 : local1 + 0) & 0xFF)) != 0) { + break label_1; + } + local1 = (arg0 + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local1 & 3)) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local1 < 0 ? local1 : local1 + 0) & 0xFF)) != 0) { + break label_1; + } + local1 = (arg0 + 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((local1 & 3)) != 0) { + break label_2; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) local1 < 0 ? local1 : local1 + 0) & 0xFF)) != 0) { + break label_1; + } + local1 = (arg0 + 4); + } + local1 = (local1 + -5); + label_3: while (true) { + local2 = (local1 + 5); + local1 = (local1 + 4); + local2 = memory.readInt((int) local2 < 0 ? local2 : local2 + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((local2 ^ -1) & (local2 + -16843009)) & -2139062144)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + label_4: while (true) { + local1 = (local1 + 1); + if (((int) memory.read((int) local1 < 0 ? local1 : local1 + 0) & 0xFF) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_4; + } + break; + } + } + return (local1 - arg0); + } + + public static long[] call_1897(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int result = Wat2WasmMachine.func_1897(arg0, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1898(int arg0, int arg1, int arg2, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local3 = 0; + int local4 = 0; + int local5 = 0; + label_1: { + if (arg2 != 0) { + break label_1; + } + return 0; + } + local3 = 0; + label_2: { + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(local4) != 0) { + break label_2; + } + arg0 = (arg0 + 1); + arg2 = (arg2 + -1); + label_3: while (true) { + label_4: { + local5 = ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF); + if (local5 != 0) { + break label_4; + } + local3 = local4; + break label_2; + } + label_5: { + if (arg2 != 0) { + break label_5; + } + local3 = local4; + break label_2; + } + label_6: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(local5, (local4 & 255)) != 0) { + break label_6; + } + local3 = local4; + break label_2; + } + arg2 = (arg2 + -1); + arg1 = (arg1 + 1); + local4 = ((int) memory.read((int) arg0 < 0 ? arg0 : arg0 + 0) & 0xFF); + arg0 = (arg0 + 1); + if (local4 != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_3; + } + break; + } + } + return ((local3 & 255) - ((int) memory.read((int) arg1 < 0 ? arg1 : arg1 + 0) & 0xFF)); + } + + public static long[] call_1898(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int arg2 = ((int) args[2]); + int result = Wat2WasmMachine.func_1898(arg0, arg1, arg2, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public static int func_1899(int arg0, int arg1, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int local2 = 0; + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) arg1); + callArgs_0[1] = ((long) 0); + callArgs_0[0] = ((long) arg0); + long[] callResult_0 = instance.getMachine().call(1888, callArgs_0); + local2 = ((int) callResult_0[0]); + return (local2 != 0 ? (local2 - arg0) : arg1); + } + + public static long[] call_1899(com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance, long[] args) { + int arg0 = ((int) args[0]); + int arg1 = ((int) args[1]); + int result = Wat2WasmMachine.func_1899(arg0, arg1, memory, instance); + long[] out = new long[1]; + out[0] = ((long) result); + return out; + } + + public long[] call(int funcId, long[] args) { + com.dylibso.chicory.runtime.Memory memory = this.instance.memory(); + try { + switch(funcId) { + case 0: + return instance.imports().function(funcId).handle().apply(instance, args); + case 1: + return instance.imports().function(funcId).handle().apply(instance, args); + case 2: + return instance.imports().function(funcId).handle().apply(instance, args); + case 3: + return instance.imports().function(funcId).handle().apply(instance, args); + case 4: + return instance.imports().function(funcId).handle().apply(instance, args); + case 5: + return instance.imports().function(funcId).handle().apply(instance, args); + case 6: + return instance.imports().function(funcId).handle().apply(instance, args); + case 7: + return instance.imports().function(funcId).handle().apply(instance, args); + case 8: + return instance.imports().function(funcId).handle().apply(instance, args); + case 9: + return instance.imports().function(funcId).handle().apply(instance, args); + case 10: + return instance.imports().function(funcId).handle().apply(instance, args); + case 11: + return instance.imports().function(funcId).handle().apply(instance, args); + case 12: + return instance.imports().function(funcId).handle().apply(instance, args); + case 13: + return instance.imports().function(funcId).handle().apply(instance, args); + case 14: + return instance.imports().function(funcId).handle().apply(instance, args); + case 15: + return Wat2WasmMachine.call_15(memory, instance, args); + case 16: + return Wat2WasmMachine.call_16(memory, instance, args); + case 17: + return Wat2WasmMachine.call_17(memory, instance, args); + case 18: + return Wat2WasmMachine.call_18(memory, instance, args); + case 19: + return Wat2WasmMachine.call_19(memory, instance, args); + case 20: + return Wat2WasmMachine.call_20(memory, instance, args); + case 21: + return Wat2WasmMachine.call_21(memory, instance, args); + case 22: + return Wat2WasmMachine.call_22(memory, instance, args); + case 23: + return Wat2WasmMachine.call_23(memory, instance, args); + case 24: + return Wat2WasmMachine.call_24(memory, instance, args); + case 25: + return Wat2WasmMachine.call_25(memory, instance, args); + case 26: + return Wat2WasmMachine.call_26(memory, instance, args); + case 27: + return Wat2WasmMachine.call_27(memory, instance, args); + case 28: + return Wat2WasmMachine.call_28(memory, instance, args); + case 29: + return Wat2WasmMachine.call_29(memory, instance, args); + case 30: + return Wat2WasmMachine.call_30(memory, instance, args); + case 31: + return Wat2WasmMachine.call_31(memory, instance, args); + case 32: + return Wat2WasmMachine.call_32(memory, instance, args); + case 33: + return Wat2WasmMachine.call_33(memory, instance, args); + case 34: + return Wat2WasmMachine.call_34(memory, instance, args); + case 35: + return Wat2WasmMachine.call_35(memory, instance, args); + case 36: + return Wat2WasmMachine.call_36(memory, instance, args); + case 37: + return Wat2WasmMachine.call_37(memory, instance, args); + case 38: + return Wat2WasmMachine.call_38(memory, instance, args); + case 39: + return Wat2WasmMachine.call_39(memory, instance, args); + case 40: + return Wat2WasmMachine.call_40(memory, instance, args); + case 41: + return Wat2WasmMachine.call_41(memory, instance, args); + case 42: + return Wat2WasmMachine.call_42(memory, instance, args); + case 43: + return Wat2WasmMachine.call_43(memory, instance, args); + case 44: + return Wat2WasmMachine.call_44(memory, instance, args); + case 45: + return Wat2WasmMachine.call_45(memory, instance, args); + case 46: + return Wat2WasmMachine.call_46(memory, instance, args); + case 47: + return Wat2WasmMachine.call_47(memory, instance, args); + case 48: + return Wat2WasmMachine.call_48(memory, instance, args); + case 49: + return Wat2WasmMachine.call_49(memory, instance, args); + case 50: + return Wat2WasmMachine.call_50(memory, instance, args); + case 51: + return Wat2WasmMachine.call_51(memory, instance, args); + case 52: + return Wat2WasmMachine.call_52(memory, instance, args); + case 53: + return Wat2WasmMachine.call_53(memory, instance, args); + case 54: + return Wat2WasmMachine.call_54(memory, instance, args); + case 55: + return Wat2WasmMachine.call_55(memory, instance, args); + case 56: + return Wat2WasmMachine.call_56(memory, instance, args); + case 57: + return Wat2WasmMachine.call_57(memory, instance, args); + case 58: + return Wat2WasmMachine.call_58(memory, instance, args); + case 59: + return Wat2WasmMachine.call_59(memory, instance, args); + case 60: + return Wat2WasmMachine.call_60(memory, instance, args); + case 61: + return Wat2WasmMachine.call_61(memory, instance, args); + case 62: + return Wat2WasmMachine.call_62(memory, instance, args); + case 63: + return Wat2WasmMachine.call_63(memory, instance, args); + case 64: + return Wat2WasmMachine.call_64(memory, instance, args); + case 65: + return Wat2WasmMachine.call_65(memory, instance, args); + case 66: + return Wat2WasmMachine.call_66(memory, instance, args); + case 67: + return Wat2WasmMachine.call_67(memory, instance, args); + case 68: + return Wat2WasmMachine.call_68(memory, instance, args); + case 69: + return Wat2WasmMachine.call_69(memory, instance, args); + case 70: + return Wat2WasmMachine.call_70(memory, instance, args); + case 71: + return Wat2WasmMachine.call_71(memory, instance, args); + case 72: + return Wat2WasmMachine.call_72(memory, instance, args); + case 73: + return Wat2WasmMachine.call_73(memory, instance, args); + case 74: + return Wat2WasmMachine.call_74(memory, instance, args); + case 75: + return Wat2WasmMachine.call_75(memory, instance, args); + case 76: + return Wat2WasmMachine.call_76(memory, instance, args); + case 77: + return Wat2WasmMachine.call_77(memory, instance, args); + case 78: + return Wat2WasmMachine.call_78(memory, instance, args); + case 79: + return Wat2WasmMachine.call_79(memory, instance, args); + case 80: + return Wat2WasmMachine.call_80(memory, instance, args); + case 81: + return Wat2WasmMachine.call_81(memory, instance, args); + case 82: + return Wat2WasmMachine.call_82(memory, instance, args); + case 83: + return Wat2WasmMachine.call_83(memory, instance, args); + case 84: + return Wat2WasmMachine.call_84(memory, instance, args); + case 85: + return Wat2WasmMachine.call_85(memory, instance, args); + case 86: + return Wat2WasmMachine.call_86(memory, instance, args); + case 87: + return Wat2WasmMachine.call_87(memory, instance, args); + case 88: + return Wat2WasmMachine.call_88(memory, instance, args); + case 89: + return Wat2WasmMachine.call_89(memory, instance, args); + case 90: + return Wat2WasmMachine.call_90(memory, instance, args); + case 91: + return Wat2WasmMachine.call_91(memory, instance, args); + case 92: + return Wat2WasmMachine.call_92(memory, instance, args); + case 93: + return Wat2WasmMachine.call_93(memory, instance, args); + case 94: + return Wat2WasmMachine.call_94(memory, instance, args); + case 95: + return Wat2WasmMachine.call_95(memory, instance, args); + case 96: + return Wat2WasmMachine.call_96(memory, instance, args); + case 97: + return Wat2WasmMachine.call_97(memory, instance, args); + case 98: + return Wat2WasmMachine.call_98(memory, instance, args); + case 99: + return Wat2WasmMachine.call_99(memory, instance, args); + case 100: + return Wat2WasmMachine.call_100(memory, instance, args); + case 101: + return Wat2WasmMachine.call_101(memory, instance, args); + case 102: + return Wat2WasmMachine.call_102(memory, instance, args); + case 103: + return Wat2WasmMachine.call_103(memory, instance, args); + case 104: + return Wat2WasmMachine.call_104(memory, instance, args); + case 105: + return Wat2WasmMachine.call_105(memory, instance, args); + case 106: + return Wat2WasmMachine.call_106(memory, instance, args); + case 107: + return Wat2WasmMachine.call_107(memory, instance, args); + case 108: + return Wat2WasmMachine.call_108(memory, instance, args); + case 109: + return Wat2WasmMachine.call_109(memory, instance, args); + case 110: + return Wat2WasmMachine.call_110(memory, instance, args); + case 111: + return Wat2WasmMachine.call_111(memory, instance, args); + case 112: + return Wat2WasmMachine.call_112(memory, instance, args); + case 113: + return Wat2WasmMachine.call_113(memory, instance, args); + case 114: + return Wat2WasmMachine.call_114(memory, instance, args); + case 115: + return Wat2WasmMachine.call_115(memory, instance, args); + case 116: + return Wat2WasmMachine.call_116(memory, instance, args); + case 117: + return Wat2WasmMachine.call_117(memory, instance, args); + case 118: + return Wat2WasmMachine.call_118(memory, instance, args); + case 119: + return Wat2WasmMachine.call_119(memory, instance, args); + case 120: + return Wat2WasmMachine.call_120(memory, instance, args); + case 121: + return Wat2WasmMachine.call_121(memory, instance, args); + case 122: + return Wat2WasmMachine.call_122(memory, instance, args); + case 123: + return Wat2WasmMachine.call_123(memory, instance, args); + case 124: + return Wat2WasmMachine.call_124(memory, instance, args); + case 125: + return Wat2WasmMachine.call_125(memory, instance, args); + case 126: + return Wat2WasmMachine.call_126(memory, instance, args); + case 127: + return Wat2WasmMachine.call_127(memory, instance, args); + case 128: + return Wat2WasmMachine.call_128(memory, instance, args); + case 129: + return Wat2WasmMachine.call_129(memory, instance, args); + case 130: + return Wat2WasmMachine.call_130(memory, instance, args); + case 131: + return Wat2WasmMachine.call_131(memory, instance, args); + case 132: + return Wat2WasmMachine.call_132(memory, instance, args); + case 133: + return Wat2WasmMachine.call_133(memory, instance, args); + case 134: + return Wat2WasmMachine.call_134(memory, instance, args); + case 135: + return Wat2WasmMachine.call_135(memory, instance, args); + case 136: + return Wat2WasmMachine.call_136(memory, instance, args); + case 137: + return Wat2WasmMachine.call_137(memory, instance, args); + case 138: + return Wat2WasmMachine.call_138(memory, instance, args); + case 139: + return Wat2WasmMachine.call_139(memory, instance, args); + case 140: + return Wat2WasmMachine.call_140(memory, instance, args); + case 141: + return Wat2WasmMachine.call_141(memory, instance, args); + case 142: + return Wat2WasmMachine.call_142(memory, instance, args); + case 143: + return Wat2WasmMachine.call_143(memory, instance, args); + case 144: + return Wat2WasmMachine.call_144(memory, instance, args); + case 145: + return Wat2WasmMachine.call_145(memory, instance, args); + case 146: + return Wat2WasmMachine.call_146(memory, instance, args); + case 147: + return Wat2WasmMachine.call_147(memory, instance, args); + case 148: + return Wat2WasmMachine.call_148(memory, instance, args); + case 149: + return Wat2WasmMachine.call_149(memory, instance, args); + case 150: + return Wat2WasmMachine.call_150(memory, instance, args); + case 151: + return Wat2WasmMachine.call_151(memory, instance, args); + case 152: + return Wat2WasmMachine.call_152(memory, instance, args); + case 153: + return Wat2WasmMachine.call_153(memory, instance, args); + case 154: + return Wat2WasmMachine.call_154(memory, instance, args); + case 155: + return Wat2WasmMachine.call_155(memory, instance, args); + case 156: + return Wat2WasmMachine.call_156(memory, instance, args); + case 157: + return Wat2WasmMachine.call_157(memory, instance, args); + case 158: + return Wat2WasmMachine.call_158(memory, instance, args); + case 159: + return Wat2WasmMachine.call_159(memory, instance, args); + case 160: + return Wat2WasmMachine.call_160(memory, instance, args); + case 161: + return Wat2WasmMachine.call_161(memory, instance, args); + case 162: + return Wat2WasmMachine.call_162(memory, instance, args); + case 163: + return Wat2WasmMachine.call_163(memory, instance, args); + case 164: + return Wat2WasmMachine.call_164(memory, instance, args); + case 165: + return Wat2WasmMachine.call_165(memory, instance, args); + case 166: + return Wat2WasmMachine.call_166(memory, instance, args); + case 167: + return Wat2WasmMachine.call_167(memory, instance, args); + case 168: + return Wat2WasmMachine.call_168(memory, instance, args); + case 169: + return Wat2WasmMachine.call_169(memory, instance, args); + case 170: + return Wat2WasmMachine.call_170(memory, instance, args); + case 171: + return Wat2WasmMachine.call_171(memory, instance, args); + case 172: + return Wat2WasmMachine.call_172(memory, instance, args); + case 173: + return Wat2WasmMachine.call_173(memory, instance, args); + case 174: + return Wat2WasmMachine.call_174(memory, instance, args); + case 175: + return Wat2WasmMachine.call_175(memory, instance, args); + case 176: + return Wat2WasmMachine.call_176(memory, instance, args); + case 177: + return Wat2WasmMachine.call_177(memory, instance, args); + case 178: + return Wat2WasmMachine.call_178(memory, instance, args); + case 179: + return Wat2WasmMachine.call_179(memory, instance, args); + case 180: + return Wat2WasmMachine.call_180(memory, instance, args); + case 181: + return Wat2WasmMachine.call_181(memory, instance, args); + case 182: + return Wat2WasmMachine.call_182(memory, instance, args); + case 183: + return Wat2WasmMachine.call_183(memory, instance, args); + case 184: + return Wat2WasmMachine.call_184(memory, instance, args); + case 185: + return Wat2WasmMachine.call_185(memory, instance, args); + case 186: + return Wat2WasmMachine.call_186(memory, instance, args); + case 187: + return Wat2WasmMachine.call_187(memory, instance, args); + case 188: + return Wat2WasmMachine.call_188(memory, instance, args); + case 189: + return Wat2WasmMachine.call_189(memory, instance, args); + case 190: + return Wat2WasmMachine.call_190(memory, instance, args); + case 191: + return Wat2WasmMachine.call_191(memory, instance, args); + case 192: + return Wat2WasmMachine.call_192(memory, instance, args); + case 193: + return Wat2WasmMachine.call_193(memory, instance, args); + case 194: + return Wat2WasmMachine.call_194(memory, instance, args); + case 195: + return Wat2WasmMachine.call_195(memory, instance, args); + case 196: + return Wat2WasmMachine.call_196(memory, instance, args); + case 197: + return Wat2WasmMachine.call_197(memory, instance, args); + case 198: + return Wat2WasmMachine.call_198(memory, instance, args); + case 199: + return Wat2WasmMachine.call_199(memory, instance, args); + case 200: + return Wat2WasmMachine.call_200(memory, instance, args); + case 201: + return Wat2WasmMachine.call_201(memory, instance, args); + case 202: + return Wat2WasmMachine.call_202(memory, instance, args); + case 203: + return Wat2WasmMachine.call_203(memory, instance, args); + case 204: + return Wat2WasmMachine.call_204(memory, instance, args); + case 205: + return Wat2WasmMachine.call_205(memory, instance, args); + case 206: + return Wat2WasmMachine.call_206(memory, instance, args); + case 207: + return Wat2WasmMachine.call_207(memory, instance, args); + case 208: + return Wat2WasmMachine.call_208(memory, instance, args); + case 209: + return Wat2WasmMachine.call_209(memory, instance, args); + case 210: + return Wat2WasmMachine.call_210(memory, instance, args); + case 211: + return Wat2WasmMachine.call_211(memory, instance, args); + case 212: + return Wat2WasmMachine.call_212(memory, instance, args); + case 213: + return Wat2WasmMachine.call_213(memory, instance, args); + case 214: + return Wat2WasmMachine.call_214(memory, instance, args); + case 215: + return Wat2WasmMachine.call_215(memory, instance, args); + case 216: + return Wat2WasmMachine.call_216(memory, instance, args); + case 217: + return Wat2WasmMachine.call_217(memory, instance, args); + case 218: + return Wat2WasmMachine.call_218(memory, instance, args); + case 219: + return Wat2WasmMachine.call_219(memory, instance, args); + case 220: + return Wat2WasmMachine.call_220(memory, instance, args); + case 221: + return Wat2WasmMachine.call_221(memory, instance, args); + case 222: + return Wat2WasmMachine.call_222(memory, instance, args); + case 223: + return Wat2WasmMachine.call_223(memory, instance, args); + case 224: + return Wat2WasmMachine.call_224(memory, instance, args); + case 225: + return Wat2WasmMachine.call_225(memory, instance, args); + case 226: + return Wat2WasmMachine.call_226(memory, instance, args); + case 227: + return Wat2WasmMachine.call_227(memory, instance, args); + case 228: + return Wat2WasmMachine.call_228(memory, instance, args); + case 229: + return Wat2WasmMachine.call_229(memory, instance, args); + case 230: + return Wat2WasmMachine.call_230(memory, instance, args); + case 231: + return Wat2WasmMachine.call_231(memory, instance, args); + case 232: + return Wat2WasmMachine.call_232(memory, instance, args); + case 233: + return Wat2WasmMachine.call_233(memory, instance, args); + case 234: + return Wat2WasmMachine.call_234(memory, instance, args); + case 235: + return Wat2WasmMachine.call_235(memory, instance, args); + case 236: + return Wat2WasmMachine.call_236(memory, instance, args); + case 237: + return Wat2WasmMachine.call_237(memory, instance, args); + case 238: + return Wat2WasmMachine.call_238(memory, instance, args); + case 239: + return Wat2WasmMachine.call_239(memory, instance, args); + case 240: + return Wat2WasmMachine.call_240(memory, instance, args); + case 241: + return Wat2WasmMachine.call_241(memory, instance, args); + case 242: + return Wat2WasmMachine.call_242(memory, instance, args); + case 243: + return Wat2WasmMachine.call_243(memory, instance, args); + case 244: + return Wat2WasmMachine.call_244(memory, instance, args); + case 245: + return Wat2WasmMachine.call_245(memory, instance, args); + case 246: + return Wat2WasmMachine.call_246(memory, instance, args); + case 247: + return Wat2WasmMachine.call_247(memory, instance, args); + case 248: + return Wat2WasmMachine.call_248(memory, instance, args); + case 249: + return Wat2WasmMachine.call_249(memory, instance, args); + case 250: + return Wat2WasmMachine.call_250(memory, instance, args); + case 251: + return Wat2WasmMachine.call_251(memory, instance, args); + case 252: + return Wat2WasmMachine.call_252(memory, instance, args); + case 253: + return Wat2WasmMachine.call_253(memory, instance, args); + case 254: + return Wat2WasmMachine.call_254(memory, instance, args); + case 255: + return Wat2WasmMachine.call_255(memory, instance, args); + case 256: + return Wat2WasmMachine.call_256(memory, instance, args); + case 257: + return Wat2WasmMachine.call_257(memory, instance, args); + case 258: + return Wat2WasmMachine.call_258(memory, instance, args); + case 259: + return Wat2WasmMachine.call_259(memory, instance, args); + case 260: + return Wat2WasmMachine.call_260(memory, instance, args); + case 261: + return Wat2WasmMachine.call_261(memory, instance, args); + case 262: + return Wat2WasmMachine.call_262(memory, instance, args); + case 263: + return Wat2WasmMachine.call_263(memory, instance, args); + case 264: + return Wat2WasmMachine.call_264(memory, instance, args); + case 265: + return Wat2WasmMachine.call_265(memory, instance, args); + case 266: + return Wat2WasmMachine.call_266(memory, instance, args); + case 267: + return Wat2WasmMachine.call_267(memory, instance, args); + case 268: + return Wat2WasmMachine.call_268(memory, instance, args); + case 269: + return Wat2WasmMachine.call_269(memory, instance, args); + case 270: + return Wat2WasmMachine.call_270(memory, instance, args); + case 271: + return Wat2WasmMachine.call_271(memory, instance, args); + case 272: + return Wat2WasmMachine.call_272(memory, instance, args); + case 273: + return Wat2WasmMachine.call_273(memory, instance, args); + case 274: + return Wat2WasmMachine.call_274(memory, instance, args); + case 275: + return Wat2WasmMachine.call_275(memory, instance, args); + case 276: + return Wat2WasmMachine.call_276(memory, instance, args); + case 277: + return Wat2WasmMachine.call_277(memory, instance, args); + case 278: + return Wat2WasmMachine.call_278(memory, instance, args); + case 279: + return Wat2WasmMachine.call_279(memory, instance, args); + case 280: + return Wat2WasmMachine.call_280(memory, instance, args); + case 281: + return Wat2WasmMachine.call_281(memory, instance, args); + case 282: + return Wat2WasmMachine.call_282(memory, instance, args); + case 283: + return Wat2WasmMachine.call_283(memory, instance, args); + case 284: + return Wat2WasmMachine.call_284(memory, instance, args); + case 285: + return Wat2WasmMachine.call_285(memory, instance, args); + case 286: + return Wat2WasmMachine.call_286(memory, instance, args); + case 287: + return Wat2WasmMachine.call_287(memory, instance, args); + case 288: + return Wat2WasmMachine.call_288(memory, instance, args); + case 289: + return Wat2WasmMachine.call_289(memory, instance, args); + case 290: + return Wat2WasmMachine.call_290(memory, instance, args); + case 291: + return Wat2WasmMachine.call_291(memory, instance, args); + case 292: + return Wat2WasmMachine.call_292(memory, instance, args); + case 293: + return Wat2WasmMachine.call_293(memory, instance, args); + case 294: + return Wat2WasmMachine.call_294(memory, instance, args); + case 295: + return Wat2WasmMachine.call_295(memory, instance, args); + case 296: + return Wat2WasmMachine.call_296(memory, instance, args); + case 297: + return Wat2WasmMachine.call_297(memory, instance, args); + case 298: + return Wat2WasmMachine.call_298(memory, instance, args); + case 299: + return Wat2WasmMachine.call_299(memory, instance, args); + case 300: + return Wat2WasmMachine.call_300(memory, instance, args); + case 301: + return Wat2WasmMachine.call_301(memory, instance, args); + case 302: + return Wat2WasmMachine.call_302(memory, instance, args); + case 303: + return Wat2WasmMachine.call_303(memory, instance, args); + case 304: + return Wat2WasmMachine.call_304(memory, instance, args); + case 305: + return Wat2WasmMachine.call_305(memory, instance, args); + case 306: + return Wat2WasmMachine.call_306(memory, instance, args); + case 307: + return Wat2WasmMachine.call_307(memory, instance, args); + case 308: + return Wat2WasmMachine.call_308(memory, instance, args); + case 309: + return Wat2WasmMachine.call_309(memory, instance, args); + case 310: + return Wat2WasmMachine.call_310(memory, instance, args); + case 311: + return Wat2WasmMachine.call_311(memory, instance, args); + case 312: + return Wat2WasmMachine.call_312(memory, instance, args); + case 313: + return Wat2WasmMachine.call_313(memory, instance, args); + case 314: + return Wat2WasmMachine.call_314(memory, instance, args); + case 315: + return Wat2WasmMachine.call_315(memory, instance, args); + case 316: + return Wat2WasmMachine.call_316(memory, instance, args); + case 317: + return Wat2WasmMachine.call_317(memory, instance, args); + case 318: + return Wat2WasmMachine.call_318(memory, instance, args); + case 319: + return Wat2WasmMachine.call_319(memory, instance, args); + case 320: + return Wat2WasmMachine.call_320(memory, instance, args); + case 321: + return Wat2WasmMachine.call_321(memory, instance, args); + case 322: + return Wat2WasmMachine.call_322(memory, instance, args); + case 323: + return Wat2WasmMachine.call_323(memory, instance, args); + case 324: + return Wat2WasmMachine.call_324(memory, instance, args); + case 325: + return Wat2WasmMachine.call_325(memory, instance, args); + case 326: + return Wat2WasmMachine.call_326(memory, instance, args); + case 327: + return Wat2WasmMachine.call_327(memory, instance, args); + case 328: + return Wat2WasmMachine.call_328(memory, instance, args); + case 329: + return Wat2WasmMachine.call_329(memory, instance, args); + case 330: + return Wat2WasmMachine.call_330(memory, instance, args); + case 331: + return Wat2WasmMachine.call_331(memory, instance, args); + case 332: + return Wat2WasmMachine.call_332(memory, instance, args); + case 333: + return Wat2WasmMachine.call_333(memory, instance, args); + case 334: + return Wat2WasmMachine.call_334(memory, instance, args); + case 335: + return Wat2WasmMachine.call_335(memory, instance, args); + case 336: + return Wat2WasmMachine.call_336(memory, instance, args); + case 337: + return Wat2WasmMachine.call_337(memory, instance, args); + case 338: + return Wat2WasmMachine.call_338(memory, instance, args); + case 339: + return Wat2WasmMachine.call_339(memory, instance, args); + case 340: + return Wat2WasmMachine.call_340(memory, instance, args); + case 341: + return Wat2WasmMachine.call_341(memory, instance, args); + case 342: + return Wat2WasmMachine.call_342(memory, instance, args); + case 343: + return Wat2WasmMachine.call_343(memory, instance, args); + case 344: + return Wat2WasmMachine.call_344(memory, instance, args); + case 345: + return Wat2WasmMachine.call_345(memory, instance, args); + case 346: + return Wat2WasmMachine.call_346(memory, instance, args); + case 347: + return Wat2WasmMachine.call_347(memory, instance, args); + case 348: + return Wat2WasmMachine.call_348(memory, instance, args); + case 349: + return Wat2WasmMachine.call_349(memory, instance, args); + case 350: + return Wat2WasmMachine.call_350(memory, instance, args); + case 351: + return Wat2WasmMachine.call_351(memory, instance, args); + case 352: + return Wat2WasmMachine.call_352(memory, instance, args); + case 353: + return Wat2WasmMachine.call_353(memory, instance, args); + case 354: + return Wat2WasmMachine.call_354(memory, instance, args); + case 355: + return Wat2WasmMachine.call_355(memory, instance, args); + case 356: + return Wat2WasmMachine.call_356(memory, instance, args); + case 357: + return Wat2WasmMachine.call_357(memory, instance, args); + case 358: + return Wat2WasmMachine.call_358(memory, instance, args); + case 359: + return Wat2WasmMachine.call_359(memory, instance, args); + case 360: + return Wat2WasmMachine.call_360(memory, instance, args); + case 361: + return Wat2WasmMachine.call_361(memory, instance, args); + case 362: + return Wat2WasmMachine.call_362(memory, instance, args); + case 363: + return Wat2WasmMachine.call_363(memory, instance, args); + case 364: + return Wat2WasmMachine.call_364(memory, instance, args); + case 365: + return Wat2WasmMachine.call_365(memory, instance, args); + case 366: + return Wat2WasmMachine.call_366(memory, instance, args); + case 367: + return Wat2WasmMachine.call_367(memory, instance, args); + case 368: + return Wat2WasmMachine.call_368(memory, instance, args); + case 369: + return Wat2WasmMachine.call_369(memory, instance, args); + case 370: + return Wat2WasmMachine.call_370(memory, instance, args); + case 371: + return Wat2WasmMachine.call_371(memory, instance, args); + case 372: + return Wat2WasmMachine.call_372(memory, instance, args); + case 373: + return Wat2WasmMachine.call_373(memory, instance, args); + case 374: + return Wat2WasmMachine.call_374(memory, instance, args); + case 375: + return Wat2WasmMachine.call_375(memory, instance, args); + case 376: + return Wat2WasmMachine.call_376(memory, instance, args); + case 377: + return Wat2WasmMachine.call_377(memory, instance, args); + case 378: + return Wat2WasmMachine.call_378(memory, instance, args); + case 379: + return Wat2WasmMachine.call_379(memory, instance, args); + case 380: + return Wat2WasmMachine.call_380(memory, instance, args); + case 381: + return Wat2WasmMachine.call_381(memory, instance, args); + case 382: + return Wat2WasmMachine.call_382(memory, instance, args); + case 383: + return Wat2WasmMachine.call_383(memory, instance, args); + case 384: + return Wat2WasmMachine.call_384(memory, instance, args); + case 385: + return Wat2WasmMachine.call_385(memory, instance, args); + case 386: + return Wat2WasmMachine.call_386(memory, instance, args); + case 387: + return Wat2WasmMachine.call_387(memory, instance, args); + case 388: + return Wat2WasmMachine.call_388(memory, instance, args); + case 389: + return Wat2WasmMachine.call_389(memory, instance, args); + case 390: + return Wat2WasmMachine.call_390(memory, instance, args); + case 391: + return Wat2WasmMachine.call_391(memory, instance, args); + case 392: + return Wat2WasmMachine.call_392(memory, instance, args); + case 393: + return Wat2WasmMachine.call_393(memory, instance, args); + case 394: + return Wat2WasmMachine.call_394(memory, instance, args); + case 395: + return Wat2WasmMachine.call_395(memory, instance, args); + case 396: + return Wat2WasmMachine.call_396(memory, instance, args); + case 397: + return Wat2WasmMachine.call_397(memory, instance, args); + case 398: + return Wat2WasmMachine.call_398(memory, instance, args); + case 399: + return Wat2WasmMachine.call_399(memory, instance, args); + case 400: + return Wat2WasmMachine.call_400(memory, instance, args); + case 401: + return Wat2WasmMachine.call_401(memory, instance, args); + case 402: + return Wat2WasmMachine.call_402(memory, instance, args); + case 403: + return Wat2WasmMachine.call_403(memory, instance, args); + case 404: + return Wat2WasmMachine.call_404(memory, instance, args); + case 405: + return Wat2WasmMachine.call_405(memory, instance, args); + case 406: + return Wat2WasmMachine.call_406(memory, instance, args); + case 407: + return Wat2WasmMachine.call_407(memory, instance, args); + case 408: + return Wat2WasmMachine.call_408(memory, instance, args); + case 409: + return Wat2WasmMachine.call_409(memory, instance, args); + case 410: + return Wat2WasmMachine.call_410(memory, instance, args); + case 411: + return Wat2WasmMachine.call_411(memory, instance, args); + case 412: + return Wat2WasmMachine.call_412(memory, instance, args); + case 413: + return Wat2WasmMachine.call_413(memory, instance, args); + case 414: + return Wat2WasmMachine.call_414(memory, instance, args); + case 415: + return Wat2WasmMachine.call_415(memory, instance, args); + case 416: + return Wat2WasmMachine.call_416(memory, instance, args); + case 417: + return Wat2WasmMachine.call_417(memory, instance, args); + case 418: + return Wat2WasmMachine.call_418(memory, instance, args); + case 419: + return Wat2WasmMachine.call_419(memory, instance, args); + case 420: + return Wat2WasmMachine.call_420(memory, instance, args); + case 421: + return Wat2WasmMachine.call_421(memory, instance, args); + case 422: + return Wat2WasmMachine.call_422(memory, instance, args); + case 423: + return Wat2WasmMachine.call_423(memory, instance, args); + case 424: + return Wat2WasmMachine.call_424(memory, instance, args); + case 425: + return Wat2WasmMachine.call_425(memory, instance, args); + case 426: + return Wat2WasmMachine.call_426(memory, instance, args); + case 427: + return Wat2WasmMachine.call_427(memory, instance, args); + case 428: + return Wat2WasmMachine.call_428(memory, instance, args); + case 429: + return Wat2WasmMachine.call_429(memory, instance, args); + case 430: + return Wat2WasmMachine.call_430(memory, instance, args); + case 431: + return Wat2WasmMachine.call_431(memory, instance, args); + case 432: + return Wat2WasmMachine.call_432(memory, instance, args); + case 433: + return Wat2WasmMachine.call_433(memory, instance, args); + case 434: + return Wat2WasmMachine.call_434(memory, instance, args); + case 435: + return Wat2WasmMachine.call_435(memory, instance, args); + case 436: + return Wat2WasmMachine.call_436(memory, instance, args); + case 437: + return Wat2WasmMachine.call_437(memory, instance, args); + case 438: + return Wat2WasmMachine.call_438(memory, instance, args); + case 439: + return Wat2WasmMachine.call_439(memory, instance, args); + case 440: + return Wat2WasmMachine.call_440(memory, instance, args); + case 441: + return Wat2WasmMachine.call_441(memory, instance, args); + case 442: + return Wat2WasmMachine.call_442(memory, instance, args); + case 443: + return Wat2WasmMachine.call_443(memory, instance, args); + case 444: + return Wat2WasmMachine.call_444(memory, instance, args); + case 445: + return Wat2WasmMachine.call_445(memory, instance, args); + case 446: + return Wat2WasmMachine.call_446(memory, instance, args); + case 447: + return Wat2WasmMachine.call_447(memory, instance, args); + case 448: + return Wat2WasmMachine.call_448(memory, instance, args); + case 449: + return Wat2WasmMachine.call_449(memory, instance, args); + case 450: + return Wat2WasmMachine.call_450(memory, instance, args); + case 451: + return Wat2WasmMachine.call_451(memory, instance, args); + case 452: + return Wat2WasmMachine.call_452(memory, instance, args); + case 453: + return Wat2WasmMachine.call_453(memory, instance, args); + case 454: + return Wat2WasmMachine.call_454(memory, instance, args); + case 455: + return Wat2WasmMachine.call_455(memory, instance, args); + case 456: + return Wat2WasmMachine.call_456(memory, instance, args); + case 457: + return Wat2WasmMachine.call_457(memory, instance, args); + case 458: + return Wat2WasmMachine.call_458(memory, instance, args); + case 459: + return Wat2WasmMachine.call_459(memory, instance, args); + case 460: + return Wat2WasmMachine.call_460(memory, instance, args); + case 461: + return Wat2WasmMachine.call_461(memory, instance, args); + case 462: + return Wat2WasmMachine.call_462(memory, instance, args); + case 463: + return Wat2WasmMachine.call_463(memory, instance, args); + case 464: + return Wat2WasmMachine.call_464(memory, instance, args); + case 465: + return Wat2WasmMachine.call_465(memory, instance, args); + case 466: + return Wat2WasmMachine.call_466(memory, instance, args); + case 467: + return Wat2WasmMachine.call_467(memory, instance, args); + case 468: + return Wat2WasmMachine.call_468(memory, instance, args); + case 469: + return Wat2WasmMachine.call_469(memory, instance, args); + case 470: + return Wat2WasmMachine.call_470(memory, instance, args); + case 471: + return Wat2WasmMachine.call_471(memory, instance, args); + case 472: + return Wat2WasmMachine.call_472(memory, instance, args); + case 473: + return Wat2WasmMachine.call_473(memory, instance, args); + case 474: + return Wat2WasmMachine.call_474(memory, instance, args); + case 475: + return Wat2WasmMachine.call_475(memory, instance, args); + case 476: + return Wat2WasmMachine.call_476(memory, instance, args); + case 477: + return Wat2WasmMachine.call_477(memory, instance, args); + case 478: + return Wat2WasmMachine.call_478(memory, instance, args); + case 479: + return Wat2WasmMachine.call_479(memory, instance, args); + case 480: + return Wat2WasmMachine.call_480(memory, instance, args); + case 481: + return Wat2WasmMachine.call_481(memory, instance, args); + case 482: + return Wat2WasmMachine.call_482(memory, instance, args); + case 483: + return Wat2WasmMachine.call_483(memory, instance, args); + case 484: + return Wat2WasmMachine.call_484(memory, instance, args); + case 485: + return Wat2WasmMachine.call_485(memory, instance, args); + case 486: + return Wat2WasmMachine.call_486(memory, instance, args); + case 487: + return Wat2WasmMachine.call_487(memory, instance, args); + case 488: + return Wat2WasmMachine.call_488(memory, instance, args); + case 489: + return Wat2WasmMachine.call_489(memory, instance, args); + case 490: + return Wat2WasmMachine.call_490(memory, instance, args); + case 491: + return Wat2WasmMachine.call_491(memory, instance, args); + case 492: + return Wat2WasmMachine.call_492(memory, instance, args); + case 493: + return Wat2WasmMachine.call_493(memory, instance, args); + case 494: + return Wat2WasmMachine.call_494(memory, instance, args); + case 495: + return Wat2WasmMachine.call_495(memory, instance, args); + case 496: + return Wat2WasmMachine.call_496(memory, instance, args); + case 497: + return Wat2WasmMachine.call_497(memory, instance, args); + case 498: + return Wat2WasmMachine.call_498(memory, instance, args); + case 499: + return Wat2WasmMachine.call_499(memory, instance, args); + case 500: + return Wat2WasmMachine.call_500(memory, instance, args); + case 501: + return Wat2WasmMachine.call_501(memory, instance, args); + case 502: + return Wat2WasmMachine.call_502(memory, instance, args); + case 503: + return Wat2WasmMachine.call_503(memory, instance, args); + case 504: + return Wat2WasmMachine.call_504(memory, instance, args); + case 505: + return Wat2WasmMachine.call_505(memory, instance, args); + case 506: + return Wat2WasmMachine.call_506(memory, instance, args); + case 507: + return Wat2WasmMachine.call_507(memory, instance, args); + case 508: + return Wat2WasmMachine.call_508(memory, instance, args); + case 509: + return Wat2WasmMachine.call_509(memory, instance, args); + case 510: + return Wat2WasmMachine.call_510(memory, instance, args); + case 511: + return Wat2WasmMachine.call_511(memory, instance, args); + case 512: + return Wat2WasmMachine.call_512(memory, instance, args); + case 513: + return Wat2WasmMachine.call_513(memory, instance, args); + case 514: + return Wat2WasmMachine.call_514(memory, instance, args); + case 515: + return Wat2WasmMachine.call_515(memory, instance, args); + case 516: + return Wat2WasmMachine.call_516(memory, instance, args); + case 517: + return Wat2WasmMachine.call_517(memory, instance, args); + case 518: + return Wat2WasmMachine.call_518(memory, instance, args); + case 519: + return Wat2WasmMachine.call_519(memory, instance, args); + case 520: + return Wat2WasmMachine.call_520(memory, instance, args); + case 521: + return Wat2WasmMachine.call_521(memory, instance, args); + case 522: + return Wat2WasmMachine.call_522(memory, instance, args); + case 523: + return Wat2WasmMachine.call_523(memory, instance, args); + case 524: + return Wat2WasmMachine.call_524(memory, instance, args); + case 525: + return Wat2WasmMachine.call_525(memory, instance, args); + case 526: + return Wat2WasmMachine.call_526(memory, instance, args); + case 527: + return Wat2WasmMachine.call_527(memory, instance, args); + case 528: + return Wat2WasmMachine.call_528(memory, instance, args); + case 529: + return Wat2WasmMachine.call_529(memory, instance, args); + case 530: + return Wat2WasmMachine.call_530(memory, instance, args); + case 531: + return Wat2WasmMachine.call_531(memory, instance, args); + case 532: + return Wat2WasmMachine.call_532(memory, instance, args); + case 533: + return Wat2WasmMachine.call_533(memory, instance, args); + case 534: + return Wat2WasmMachine.call_534(memory, instance, args); + case 535: + return Wat2WasmMachine.call_535(memory, instance, args); + case 536: + return Wat2WasmMachine.call_536(memory, instance, args); + case 537: + return Wat2WasmMachine.call_537(memory, instance, args); + case 538: + return Wat2WasmMachine.call_538(memory, instance, args); + case 539: + return Wat2WasmMachine.call_539(memory, instance, args); + case 540: + return Wat2WasmMachine.call_540(memory, instance, args); + case 541: + return Wat2WasmMachine.call_541(memory, instance, args); + case 542: + return Wat2WasmMachine.call_542(memory, instance, args); + case 543: + return Wat2WasmMachine.call_543(memory, instance, args); + case 544: + return Wat2WasmMachine.call_544(memory, instance, args); + case 545: + return Wat2WasmMachine.call_545(memory, instance, args); + case 546: + return Wat2WasmMachine.call_546(memory, instance, args); + case 547: + return Wat2WasmMachine.call_547(memory, instance, args); + case 548: + return Wat2WasmMachine.call_548(memory, instance, args); + case 549: + return Wat2WasmMachine.call_549(memory, instance, args); + case 550: + return Wat2WasmMachine.call_550(memory, instance, args); + case 551: + return Wat2WasmMachine.call_551(memory, instance, args); + case 552: + return Wat2WasmMachine.call_552(memory, instance, args); + case 553: + return Wat2WasmMachine.call_553(memory, instance, args); + case 554: + return Wat2WasmMachine.call_554(memory, instance, args); + case 555: + return Wat2WasmMachine.call_555(memory, instance, args); + case 556: + return Wat2WasmMachine.call_556(memory, instance, args); + case 557: + return Wat2WasmMachine.call_557(memory, instance, args); + case 558: + return Wat2WasmMachine.call_558(memory, instance, args); + case 559: + return Wat2WasmMachine.call_559(memory, instance, args); + case 560: + return Wat2WasmMachine.call_560(memory, instance, args); + case 561: + return Wat2WasmMachine.call_561(memory, instance, args); + case 562: + return Wat2WasmMachine.call_562(memory, instance, args); + case 563: + return Wat2WasmMachine.call_563(memory, instance, args); + case 564: + return Wat2WasmMachine.call_564(memory, instance, args); + case 565: + return Wat2WasmMachine.call_565(memory, instance, args); + case 566: + return Wat2WasmMachine.call_566(memory, instance, args); + case 567: + return Wat2WasmMachine.call_567(memory, instance, args); + case 568: + return Wat2WasmMachine.call_568(memory, instance, args); + case 569: + return Wat2WasmMachine.call_569(memory, instance, args); + case 570: + return Wat2WasmMachine.call_570(memory, instance, args); + case 571: + return Wat2WasmMachine.call_571(memory, instance, args); + case 572: + return Wat2WasmMachine.call_572(memory, instance, args); + case 573: + return Wat2WasmMachine.call_573(memory, instance, args); + case 574: + return Wat2WasmMachine.call_574(memory, instance, args); + case 575: + return Wat2WasmMachine.call_575(memory, instance, args); + case 576: + return Wat2WasmMachine.call_576(memory, instance, args); + case 577: + return Wat2WasmMachine.call_577(memory, instance, args); + case 578: + return Wat2WasmMachine.call_578(memory, instance, args); + case 579: + return Wat2WasmMachine.call_579(memory, instance, args); + case 580: + return Wat2WasmMachine.call_580(memory, instance, args); + case 581: + return Wat2WasmMachine.call_581(memory, instance, args); + case 582: + return Wat2WasmMachine.call_582(memory, instance, args); + case 583: + return Wat2WasmMachine.call_583(memory, instance, args); + case 584: + return Wat2WasmMachine.call_584(memory, instance, args); + case 585: + return Wat2WasmMachine.call_585(memory, instance, args); + case 586: + return Wat2WasmMachine.call_586(memory, instance, args); + case 587: + return Wat2WasmMachine.call_587(memory, instance, args); + case 588: + return Wat2WasmMachine.call_588(memory, instance, args); + case 589: + return Wat2WasmMachine.call_589(memory, instance, args); + case 590: + return Wat2WasmMachine.call_590(memory, instance, args); + case 591: + return Wat2WasmMachine.call_591(memory, instance, args); + case 592: + return Wat2WasmMachine.call_592(memory, instance, args); + case 593: + return Wat2WasmMachine.call_593(memory, instance, args); + case 594: + return Wat2WasmMachine.call_594(memory, instance, args); + case 595: + return Wat2WasmMachine.call_595(memory, instance, args); + case 596: + return Wat2WasmMachine.call_596(memory, instance, args); + case 597: + return Wat2WasmMachine.call_597(memory, instance, args); + case 598: + return Wat2WasmMachine.call_598(memory, instance, args); + case 599: + return Wat2WasmMachine.call_599(memory, instance, args); + case 600: + return Wat2WasmMachine.call_600(memory, instance, args); + case 601: + return Wat2WasmMachine.call_601(memory, instance, args); + case 602: + return Wat2WasmMachine.call_602(memory, instance, args); + case 603: + return Wat2WasmMachine.call_603(memory, instance, args); + case 604: + return Wat2WasmMachine.call_604(memory, instance, args); + case 605: + return Wat2WasmMachine.call_605(memory, instance, args); + case 606: + return Wat2WasmMachine.call_606(memory, instance, args); + case 607: + return Wat2WasmMachine.call_607(memory, instance, args); + case 608: + return Wat2WasmMachine.call_608(memory, instance, args); + case 609: + return Wat2WasmMachine.call_609(memory, instance, args); + case 610: + return Wat2WasmMachine.call_610(memory, instance, args); + case 611: + return Wat2WasmMachine.call_611(memory, instance, args); + case 612: + return Wat2WasmMachine.call_612(memory, instance, args); + case 613: + return Wat2WasmMachine.call_613(memory, instance, args); + case 614: + return Wat2WasmMachine.call_614(memory, instance, args); + case 615: + return Wat2WasmMachine.call_615(memory, instance, args); + case 616: + return Wat2WasmMachine.call_616(memory, instance, args); + case 617: + return Wat2WasmMachine.call_617(memory, instance, args); + case 618: + return Wat2WasmMachine.call_618(memory, instance, args); + case 619: + return Wat2WasmMachine.call_619(memory, instance, args); + case 620: + return Wat2WasmMachine.call_620(memory, instance, args); + case 621: + return Wat2WasmMachine.call_621(memory, instance, args); + case 622: + return Wat2WasmMachine.call_622(memory, instance, args); + case 623: + return Wat2WasmMachine.call_623(memory, instance, args); + case 624: + return Wat2WasmMachine.call_624(memory, instance, args); + case 625: + return Wat2WasmMachine.call_625(memory, instance, args); + case 626: + return Wat2WasmMachine.call_626(memory, instance, args); + case 627: + return Wat2WasmMachine.call_627(memory, instance, args); + case 628: + return Wat2WasmMachine.call_628(memory, instance, args); + case 629: + return Wat2WasmMachine.call_629(memory, instance, args); + case 630: + return Wat2WasmMachine.call_630(memory, instance, args); + case 631: + return Wat2WasmMachine.call_631(memory, instance, args); + case 632: + return Wat2WasmMachine.call_632(memory, instance, args); + case 633: + return Wat2WasmMachine.call_633(memory, instance, args); + case 634: + return Wat2WasmMachine.call_634(memory, instance, args); + case 635: + return Wat2WasmMachine.call_635(memory, instance, args); + case 636: + return Wat2WasmMachine.call_636(memory, instance, args); + case 637: + return Wat2WasmMachine.call_637(memory, instance, args); + case 638: + return Wat2WasmMachine.call_638(memory, instance, args); + case 639: + return Wat2WasmMachine.call_639(memory, instance, args); + case 640: + return Wat2WasmMachine.call_640(memory, instance, args); + case 641: + return Wat2WasmMachine.call_641(memory, instance, args); + case 642: + return Wat2WasmMachine.call_642(memory, instance, args); + case 643: + return Wat2WasmMachine.call_643(memory, instance, args); + case 644: + return Wat2WasmMachine.call_644(memory, instance, args); + case 645: + return Wat2WasmMachine.call_645(memory, instance, args); + case 646: + return Wat2WasmMachine.call_646(memory, instance, args); + case 647: + return Wat2WasmMachine.call_647(memory, instance, args); + case 648: + return Wat2WasmMachine.call_648(memory, instance, args); + case 649: + return Wat2WasmMachine.call_649(memory, instance, args); + case 650: + return Wat2WasmMachine.call_650(memory, instance, args); + case 651: + return Wat2WasmMachine.call_651(memory, instance, args); + case 652: + return Wat2WasmMachine.call_652(memory, instance, args); + case 653: + return Wat2WasmMachine.call_653(memory, instance, args); + case 654: + return Wat2WasmMachine.call_654(memory, instance, args); + case 655: + return Wat2WasmMachine.call_655(memory, instance, args); + case 656: + return Wat2WasmMachine.call_656(memory, instance, args); + case 657: + return Wat2WasmMachine.call_657(memory, instance, args); + case 658: + return Wat2WasmMachine.call_658(memory, instance, args); + case 659: + return Wat2WasmMachine.call_659(memory, instance, args); + case 660: + return Wat2WasmMachine.call_660(memory, instance, args); + case 661: + return Wat2WasmMachine.call_661(memory, instance, args); + case 662: + return Wat2WasmMachine.call_662(memory, instance, args); + case 663: + return Wat2WasmMachine.call_663(memory, instance, args); + case 664: + return Wat2WasmMachine.call_664(memory, instance, args); + case 665: + return Wat2WasmMachine.call_665(memory, instance, args); + case 666: + return Wat2WasmMachine.call_666(memory, instance, args); + case 667: + return Wat2WasmMachine.call_667(memory, instance, args); + case 668: + return Wat2WasmMachine.call_668(memory, instance, args); + case 669: + return Wat2WasmMachine.call_669(memory, instance, args); + case 670: + return Wat2WasmMachine.call_670(memory, instance, args); + case 671: + return Wat2WasmMachine.call_671(memory, instance, args); + case 672: + return Wat2WasmMachine.call_672(memory, instance, args); + case 673: + return Wat2WasmMachine.call_673(memory, instance, args); + case 674: + return Wat2WasmMachine.call_674(memory, instance, args); + case 675: + return Wat2WasmMachine.call_675(memory, instance, args); + case 676: + return Wat2WasmMachine.call_676(memory, instance, args); + case 677: + return Wat2WasmMachine.call_677(memory, instance, args); + case 678: + return Wat2WasmMachine.call_678(memory, instance, args); + case 679: + return Wat2WasmMachine.call_679(memory, instance, args); + case 680: + return Wat2WasmMachine.call_680(memory, instance, args); + case 681: + return Wat2WasmMachine.call_681(memory, instance, args); + case 682: + return Wat2WasmMachine.call_682(memory, instance, args); + case 683: + return Wat2WasmMachine.call_683(memory, instance, args); + case 684: + return Wat2WasmMachine.call_684(memory, instance, args); + case 685: + return Wat2WasmMachine.call_685(memory, instance, args); + case 686: + return Wat2WasmMachine.call_686(memory, instance, args); + case 687: + return Wat2WasmMachine.call_687(memory, instance, args); + case 688: + return Wat2WasmMachine.call_688(memory, instance, args); + case 689: + return Wat2WasmMachine.call_689(memory, instance, args); + case 690: + return Wat2WasmMachine.call_690(memory, instance, args); + case 691: + return Wat2WasmMachine.call_691(memory, instance, args); + case 692: + return Wat2WasmMachine.call_692(memory, instance, args); + case 693: + return Wat2WasmMachine.call_693(memory, instance, args); + case 694: + return Wat2WasmMachine.call_694(memory, instance, args); + case 695: + return Wat2WasmMachine.call_695(memory, instance, args); + case 696: + return Wat2WasmMachine.call_696(memory, instance, args); + case 697: + return Wat2WasmMachine.call_697(memory, instance, args); + case 698: + return Wat2WasmMachine.call_698(memory, instance, args); + case 699: + return Wat2WasmMachine.call_699(memory, instance, args); + case 700: + return Wat2WasmMachine.call_700(memory, instance, args); + case 701: + return Wat2WasmMachine.call_701(memory, instance, args); + case 702: + return Wat2WasmMachine.call_702(memory, instance, args); + case 703: + return Wat2WasmMachine.call_703(memory, instance, args); + case 704: + return Wat2WasmMachine.call_704(memory, instance, args); + case 705: + return Wat2WasmMachine.call_705(memory, instance, args); + case 706: + return Wat2WasmMachine.call_706(memory, instance, args); + case 707: + return Wat2WasmMachine.call_707(memory, instance, args); + case 708: + return Wat2WasmMachine.call_708(memory, instance, args); + case 709: + return Wat2WasmMachine.call_709(memory, instance, args); + case 710: + return Wat2WasmMachine.call_710(memory, instance, args); + case 711: + return Wat2WasmMachine.call_711(memory, instance, args); + case 712: + return Wat2WasmMachine.call_712(memory, instance, args); + case 713: + return Wat2WasmMachine.call_713(memory, instance, args); + case 714: + return Wat2WasmMachine.call_714(memory, instance, args); + case 715: + return Wat2WasmMachine.call_715(memory, instance, args); + case 716: + return Wat2WasmMachine.call_716(memory, instance, args); + case 717: + return Wat2WasmMachine.call_717(memory, instance, args); + case 718: + return Wat2WasmMachine.call_718(memory, instance, args); + case 719: + return Wat2WasmMachine.call_719(memory, instance, args); + case 720: + return Wat2WasmMachine.call_720(memory, instance, args); + case 721: + return Wat2WasmMachine.call_721(memory, instance, args); + case 722: + return Wat2WasmMachine.call_722(memory, instance, args); + case 723: + return Wat2WasmMachine.call_723(memory, instance, args); + case 724: + return Wat2WasmMachine.call_724(memory, instance, args); + case 725: + return Wat2WasmMachine.call_725(memory, instance, args); + case 726: + return Wat2WasmMachine.call_726(memory, instance, args); + case 727: + return Wat2WasmMachine.call_727(memory, instance, args); + case 728: + return Wat2WasmMachine.call_728(memory, instance, args); + case 729: + return Wat2WasmMachine.call_729(memory, instance, args); + case 730: + return Wat2WasmMachine.call_730(memory, instance, args); + case 731: + return Wat2WasmMachine.call_731(memory, instance, args); + case 732: + return Wat2WasmMachine.call_732(memory, instance, args); + case 733: + return Wat2WasmMachine.call_733(memory, instance, args); + case 734: + return Wat2WasmMachine.call_734(memory, instance, args); + case 735: + return Wat2WasmMachine.call_735(memory, instance, args); + case 736: + return Wat2WasmMachine.call_736(memory, instance, args); + case 737: + return Wat2WasmMachine.call_737(memory, instance, args); + case 738: + return Wat2WasmMachine.call_738(memory, instance, args); + case 739: + return Wat2WasmMachine.call_739(memory, instance, args); + case 740: + return Wat2WasmMachine.call_740(memory, instance, args); + case 741: + return Wat2WasmMachine.call_741(memory, instance, args); + case 742: + return Wat2WasmMachine.call_742(memory, instance, args); + case 743: + return Wat2WasmMachine.call_743(memory, instance, args); + case 744: + return Wat2WasmMachine.call_744(memory, instance, args); + case 745: + return Wat2WasmMachine.call_745(memory, instance, args); + case 746: + return Wat2WasmMachine.call_746(memory, instance, args); + case 747: + return Wat2WasmMachine.call_747(memory, instance, args); + case 748: + return Wat2WasmMachine.call_748(memory, instance, args); + case 749: + return Wat2WasmMachine.call_749(memory, instance, args); + case 750: + return Wat2WasmMachine.call_750(memory, instance, args); + case 751: + return Wat2WasmMachine.call_751(memory, instance, args); + case 752: + return Wat2WasmMachine.call_752(memory, instance, args); + case 753: + return Wat2WasmMachine.call_753(memory, instance, args); + case 754: + return Wat2WasmMachine.call_754(memory, instance, args); + case 755: + return Wat2WasmMachine.call_755(memory, instance, args); + case 756: + return Wat2WasmMachine.call_756(memory, instance, args); + case 757: + return Wat2WasmMachine.call_757(memory, instance, args); + case 758: + return Wat2WasmMachine.call_758(memory, instance, args); + case 759: + return Wat2WasmMachine.call_759(memory, instance, args); + case 760: + return Wat2WasmMachine.call_760(memory, instance, args); + case 761: + return Wat2WasmMachine.call_761(memory, instance, args); + case 762: + return Wat2WasmMachine.call_762(memory, instance, args); + case 763: + return Wat2WasmMachine.call_763(memory, instance, args); + case 764: + return Wat2WasmMachine.call_764(memory, instance, args); + case 765: + return Wat2WasmMachine.call_765(memory, instance, args); + case 766: + return Wat2WasmMachine.call_766(memory, instance, args); + case 767: + return Wat2WasmMachine.call_767(memory, instance, args); + case 768: + return Wat2WasmMachine.call_768(memory, instance, args); + case 769: + return Wat2WasmMachine.call_769(memory, instance, args); + case 770: + return Wat2WasmMachine.call_770(memory, instance, args); + case 771: + return Wat2WasmMachine.call_771(memory, instance, args); + case 772: + return Wat2WasmMachine.call_772(memory, instance, args); + case 773: + return Wat2WasmMachine.call_773(memory, instance, args); + case 774: + return Wat2WasmMachine.call_774(memory, instance, args); + case 775: + return Wat2WasmMachine.call_775(memory, instance, args); + case 776: + return Wat2WasmMachine.call_776(memory, instance, args); + case 777: + return Wat2WasmMachine.call_777(memory, instance, args); + case 778: + return Wat2WasmMachine.call_778(memory, instance, args); + case 779: + return Wat2WasmMachine.call_779(memory, instance, args); + case 780: + return Wat2WasmMachine.call_780(memory, instance, args); + case 781: + return Wat2WasmMachine.call_781(memory, instance, args); + case 782: + return Wat2WasmMachine.call_782(memory, instance, args); + case 783: + return Wat2WasmMachine.call_783(memory, instance, args); + case 784: + return Wat2WasmMachine.call_784(memory, instance, args); + case 785: + return Wat2WasmMachine.call_785(memory, instance, args); + case 786: + return Wat2WasmMachine.call_786(memory, instance, args); + case 787: + return Wat2WasmMachine.call_787(memory, instance, args); + case 788: + return Wat2WasmMachine.call_788(memory, instance, args); + case 789: + return Wat2WasmMachine.call_789(memory, instance, args); + case 790: + return Wat2WasmMachine.call_790(memory, instance, args); + case 791: + return Wat2WasmMachine.call_791(memory, instance, args); + case 792: + return Wat2WasmMachine.call_792(memory, instance, args); + case 793: + return Wat2WasmMachine.call_793(memory, instance, args); + case 794: + return Wat2WasmMachine.call_794(memory, instance, args); + case 795: + return Wat2WasmMachine.call_795(memory, instance, args); + case 796: + return Wat2WasmMachine.call_796(memory, instance, args); + case 797: + return Wat2WasmMachine.call_797(memory, instance, args); + case 798: + return Wat2WasmMachine.call_798(memory, instance, args); + case 799: + return Wat2WasmMachine.call_799(memory, instance, args); + case 800: + return Wat2WasmMachine.call_800(memory, instance, args); + case 801: + return Wat2WasmMachine.call_801(memory, instance, args); + case 802: + return Wat2WasmMachine.call_802(memory, instance, args); + case 803: + return Wat2WasmMachine.call_803(memory, instance, args); + case 804: + return Wat2WasmMachine.call_804(memory, instance, args); + case 805: + return Wat2WasmMachine.call_805(memory, instance, args); + case 806: + return Wat2WasmMachine.call_806(memory, instance, args); + case 807: + return Wat2WasmMachine.call_807(memory, instance, args); + case 808: + return Wat2WasmMachine.call_808(memory, instance, args); + case 809: + return Wat2WasmMachine.call_809(memory, instance, args); + case 810: + return Wat2WasmMachine.call_810(memory, instance, args); + case 811: + return Wat2WasmMachine.call_811(memory, instance, args); + case 812: + return Wat2WasmMachine.call_812(memory, instance, args); + case 813: + return Wat2WasmMachine.call_813(memory, instance, args); + case 814: + return Wat2WasmMachine.call_814(memory, instance, args); + case 815: + return Wat2WasmMachine.call_815(memory, instance, args); + case 816: + return Wat2WasmMachine.call_816(memory, instance, args); + case 817: + return Wat2WasmMachine.call_817(memory, instance, args); + case 818: + return Wat2WasmMachine.call_818(memory, instance, args); + case 819: + return Wat2WasmMachine.call_819(memory, instance, args); + case 820: + return Wat2WasmMachine.call_820(memory, instance, args); + case 821: + return Wat2WasmMachine.call_821(memory, instance, args); + case 822: + return Wat2WasmMachine.call_822(memory, instance, args); + case 823: + return Wat2WasmMachine.call_823(memory, instance, args); + case 824: + return Wat2WasmMachine.call_824(memory, instance, args); + case 825: + return Wat2WasmMachine.call_825(memory, instance, args); + case 826: + return Wat2WasmMachine.call_826(memory, instance, args); + case 827: + return Wat2WasmMachine.call_827(memory, instance, args); + case 828: + return Wat2WasmMachine.call_828(memory, instance, args); + case 829: + return Wat2WasmMachine.call_829(memory, instance, args); + case 830: + return Wat2WasmMachine.call_830(memory, instance, args); + case 831: + return Wat2WasmMachine.call_831(memory, instance, args); + case 832: + return Wat2WasmMachine.call_832(memory, instance, args); + case 833: + return Wat2WasmMachine.call_833(memory, instance, args); + case 834: + return Wat2WasmMachine.call_834(memory, instance, args); + case 835: + return Wat2WasmMachine.call_835(memory, instance, args); + case 836: + return Wat2WasmMachine.call_836(memory, instance, args); + case 837: + return Wat2WasmMachine.call_837(memory, instance, args); + case 838: + return Wat2WasmMachine.call_838(memory, instance, args); + case 839: + return Wat2WasmMachine.call_839(memory, instance, args); + case 840: + return Wat2WasmMachine.call_840(memory, instance, args); + case 841: + return Wat2WasmMachine.call_841(memory, instance, args); + case 842: + return Wat2WasmMachine.call_842(memory, instance, args); + case 843: + return Wat2WasmMachine.call_843(memory, instance, args); + case 844: + return Wat2WasmMachine.call_844(memory, instance, args); + case 845: + return Wat2WasmMachine.call_845(memory, instance, args); + case 846: + return Wat2WasmMachine.call_846(memory, instance, args); + case 847: + return Wat2WasmMachine.call_847(memory, instance, args); + case 848: + return Wat2WasmMachine.call_848(memory, instance, args); + case 849: + return Wat2WasmMachine.call_849(memory, instance, args); + case 850: + return Wat2WasmMachine.call_850(memory, instance, args); + case 851: + return Wat2WasmMachine.call_851(memory, instance, args); + case 852: + return Wat2WasmMachine.call_852(memory, instance, args); + case 853: + return Wat2WasmMachine.call_853(memory, instance, args); + case 854: + return Wat2WasmMachine.call_854(memory, instance, args); + case 855: + return Wat2WasmMachine.call_855(memory, instance, args); + case 856: + return Wat2WasmMachine.call_856(memory, instance, args); + case 857: + return Wat2WasmMachine.call_857(memory, instance, args); + case 858: + return Wat2WasmMachine.call_858(memory, instance, args); + case 859: + return Wat2WasmMachine.call_859(memory, instance, args); + case 860: + return Wat2WasmMachine.call_860(memory, instance, args); + case 861: + return Wat2WasmMachine.call_861(memory, instance, args); + case 862: + return Wat2WasmMachine.call_862(memory, instance, args); + case 863: + return Wat2WasmMachine.call_863(memory, instance, args); + case 864: + return Wat2WasmMachine.call_864(memory, instance, args); + case 865: + return Wat2WasmMachine.call_865(memory, instance, args); + case 866: + return Wat2WasmMachine.call_866(memory, instance, args); + case 867: + return Wat2WasmMachine.call_867(memory, instance, args); + case 868: + return Wat2WasmMachine.call_868(memory, instance, args); + case 869: + return Wat2WasmMachine.call_869(memory, instance, args); + case 870: + return Wat2WasmMachine.call_870(memory, instance, args); + case 871: + return Wat2WasmMachine.call_871(memory, instance, args); + case 872: + return Wat2WasmMachine.call_872(memory, instance, args); + case 873: + return Wat2WasmMachine.call_873(memory, instance, args); + case 874: + return Wat2WasmMachine.call_874(memory, instance, args); + case 875: + return Wat2WasmMachine.call_875(memory, instance, args); + case 876: + return Wat2WasmMachine.call_876(memory, instance, args); + case 877: + return Wat2WasmMachine.call_877(memory, instance, args); + case 878: + return Wat2WasmMachine.call_878(memory, instance, args); + case 879: + return Wat2WasmMachine.call_879(memory, instance, args); + case 880: + return Wat2WasmMachine.call_880(memory, instance, args); + case 881: + return Wat2WasmMachine.call_881(memory, instance, args); + case 882: + return Wat2WasmMachine.call_882(memory, instance, args); + case 883: + return Wat2WasmMachine.call_883(memory, instance, args); + case 884: + return Wat2WasmMachine.call_884(memory, instance, args); + case 885: + return Wat2WasmMachine.call_885(memory, instance, args); + case 886: + return Wat2WasmMachine.call_886(memory, instance, args); + case 887: + return Wat2WasmMachine.call_887(memory, instance, args); + case 888: + return Wat2WasmMachine.call_888(memory, instance, args); + case 889: + return Wat2WasmMachine.call_889(memory, instance, args); + case 890: + return Wat2WasmMachine.call_890(memory, instance, args); + case 891: + return Wat2WasmMachine.call_891(memory, instance, args); + case 892: + return Wat2WasmMachine.call_892(memory, instance, args); + case 893: + return Wat2WasmMachine.call_893(memory, instance, args); + case 894: + return Wat2WasmMachine.call_894(memory, instance, args); + case 895: + return Wat2WasmMachine.call_895(memory, instance, args); + case 896: + return Wat2WasmMachine.call_896(memory, instance, args); + case 897: + return Wat2WasmMachine.call_897(memory, instance, args); + case 898: + return Wat2WasmMachine.call_898(memory, instance, args); + case 899: + return Wat2WasmMachine.call_899(memory, instance, args); + case 900: + return Wat2WasmMachine.call_900(memory, instance, args); + case 901: + return Wat2WasmMachine.call_901(memory, instance, args); + case 902: + return Wat2WasmMachine.call_902(memory, instance, args); + case 903: + return Wat2WasmMachine.call_903(memory, instance, args); + case 904: + return Wat2WasmMachine.call_904(memory, instance, args); + case 905: + return Wat2WasmMachine.call_905(memory, instance, args); + case 906: + return Wat2WasmMachine.call_906(memory, instance, args); + case 907: + return Wat2WasmMachine.call_907(memory, instance, args); + case 908: + return Wat2WasmMachine.call_908(memory, instance, args); + case 909: + return Wat2WasmMachine.call_909(memory, instance, args); + case 910: + return Wat2WasmMachine.call_910(memory, instance, args); + case 911: + return Wat2WasmMachine.call_911(memory, instance, args); + case 912: + return Wat2WasmMachine.call_912(memory, instance, args); + case 913: + return Wat2WasmMachine.call_913(memory, instance, args); + case 914: + return Wat2WasmMachine.call_914(memory, instance, args); + case 915: + return Wat2WasmMachine.call_915(memory, instance, args); + case 916: + return Wat2WasmMachine.call_916(memory, instance, args); + case 917: + return Wat2WasmMachine.call_917(memory, instance, args); + case 918: + return Wat2WasmMachine.call_918(memory, instance, args); + case 919: + return Wat2WasmMachine.call_919(memory, instance, args); + case 920: + return Wat2WasmMachine.call_920(memory, instance, args); + case 921: + return Wat2WasmMachine.call_921(memory, instance, args); + case 922: + return Wat2WasmMachine.call_922(memory, instance, args); + case 923: + return Wat2WasmMachine.call_923(memory, instance, args); + case 924: + return Wat2WasmMachine.call_924(memory, instance, args); + case 925: + return Wat2WasmMachine.call_925(memory, instance, args); + case 926: + return Wat2WasmMachine.call_926(memory, instance, args); + case 927: + return Wat2WasmMachine.call_927(memory, instance, args); + case 928: + return Wat2WasmMachine.call_928(memory, instance, args); + case 929: + return Wat2WasmMachine.call_929(memory, instance, args); + case 930: + return Wat2WasmMachine.call_930(memory, instance, args); + case 931: + return Wat2WasmMachine.call_931(memory, instance, args); + case 932: + return Wat2WasmMachine.call_932(memory, instance, args); + case 933: + return Wat2WasmMachine.call_933(memory, instance, args); + case 934: + return Wat2WasmMachine.call_934(memory, instance, args); + case 935: + return Wat2WasmMachine.call_935(memory, instance, args); + case 936: + return Wat2WasmMachine.call_936(memory, instance, args); + case 937: + return Wat2WasmMachine.call_937(memory, instance, args); + case 938: + return Wat2WasmMachine.call_938(memory, instance, args); + case 939: + return Wat2WasmMachine.call_939(memory, instance, args); + case 940: + return Wat2WasmMachine.call_940(memory, instance, args); + case 941: + return Wat2WasmMachine.call_941(memory, instance, args); + case 942: + return Wat2WasmMachine.call_942(memory, instance, args); + case 943: + return Wat2WasmMachine.call_943(memory, instance, args); + case 944: + return Wat2WasmMachine.call_944(memory, instance, args); + case 945: + return Wat2WasmMachine.call_945(memory, instance, args); + case 946: + return Wat2WasmMachine.call_946(memory, instance, args); + case 947: + return Wat2WasmMachine.call_947(memory, instance, args); + case 948: + return Wat2WasmMachine.call_948(memory, instance, args); + case 949: + return Wat2WasmMachine.call_949(memory, instance, args); + case 950: + return Wat2WasmMachine.call_950(memory, instance, args); + case 951: + return Wat2WasmMachine.call_951(memory, instance, args); + case 952: + return Wat2WasmMachine.call_952(memory, instance, args); + case 953: + return Wat2WasmMachine.call_953(memory, instance, args); + case 954: + return Wat2WasmMachine.call_954(memory, instance, args); + case 955: + return Wat2WasmMachine.call_955(memory, instance, args); + case 956: + return Wat2WasmMachine.call_956(memory, instance, args); + case 957: + return Wat2WasmMachine.call_957(memory, instance, args); + case 958: + return Wat2WasmMachine.call_958(memory, instance, args); + case 959: + return Wat2WasmMachine.call_959(memory, instance, args); + case 960: + return Wat2WasmMachine.call_960(memory, instance, args); + case 961: + return Wat2WasmMachine.call_961(memory, instance, args); + case 962: + return Wat2WasmMachine.call_962(memory, instance, args); + case 963: + return Wat2WasmMachine.call_963(memory, instance, args); + case 964: + return Wat2WasmMachine.call_964(memory, instance, args); + case 965: + return Wat2WasmMachine.call_965(memory, instance, args); + case 966: + return Wat2WasmMachine.call_966(memory, instance, args); + case 967: + return Wat2WasmMachine.call_967(memory, instance, args); + case 968: + return Wat2WasmMachine.call_968(memory, instance, args); + case 969: + return Wat2WasmMachine.call_969(memory, instance, args); + case 970: + return Wat2WasmMachine.call_970(memory, instance, args); + case 971: + return Wat2WasmMachine.call_971(memory, instance, args); + case 972: + return Wat2WasmMachine.call_972(memory, instance, args); + case 973: + return Wat2WasmMachine.call_973(memory, instance, args); + case 974: + return Wat2WasmMachine.call_974(memory, instance, args); + case 975: + return Wat2WasmMachine.call_975(memory, instance, args); + case 976: + return Wat2WasmMachine.call_976(memory, instance, args); + case 977: + return Wat2WasmMachine.call_977(memory, instance, args); + case 978: + return Wat2WasmMachine.call_978(memory, instance, args); + case 979: + return Wat2WasmMachine.call_979(memory, instance, args); + case 980: + return Wat2WasmMachine.call_980(memory, instance, args); + case 981: + return Wat2WasmMachine.call_981(memory, instance, args); + case 982: + return Wat2WasmMachine.call_982(memory, instance, args); + case 983: + return Wat2WasmMachine.call_983(memory, instance, args); + case 984: + return Wat2WasmMachine.call_984(memory, instance, args); + case 985: + return Wat2WasmMachine.call_985(memory, instance, args); + case 986: + return Wat2WasmMachine.call_986(memory, instance, args); + case 987: + return Wat2WasmMachine.call_987(memory, instance, args); + case 988: + return Wat2WasmMachine.call_988(memory, instance, args); + case 989: + return Wat2WasmMachine.call_989(memory, instance, args); + case 990: + return Wat2WasmMachine.call_990(memory, instance, args); + case 991: + return Wat2WasmMachine.call_991(memory, instance, args); + case 992: + return Wat2WasmMachine.call_992(memory, instance, args); + case 993: + return Wat2WasmMachine.call_993(memory, instance, args); + case 994: + return Wat2WasmMachine.call_994(memory, instance, args); + case 995: + return Wat2WasmMachine.call_995(memory, instance, args); + case 996: + return Wat2WasmMachine.call_996(memory, instance, args); + case 997: + return Wat2WasmMachine.call_997(memory, instance, args); + case 998: + return Wat2WasmMachine.call_998(memory, instance, args); + case 999: + return Wat2WasmMachine.call_999(memory, instance, args); + case 1000: + return Wat2WasmMachine.call_1000(memory, instance, args); + case 1001: + return Wat2WasmMachine.call_1001(memory, instance, args); + case 1002: + return Wat2WasmMachine.call_1002(memory, instance, args); + case 1003: + return Wat2WasmMachine.call_1003(memory, instance, args); + case 1004: + return Wat2WasmMachine.call_1004(memory, instance, args); + case 1005: + return Wat2WasmMachine.call_1005(memory, instance, args); + case 1006: + return Wat2WasmMachine.call_1006(memory, instance, args); + case 1007: + return Wat2WasmMachine.call_1007(memory, instance, args); + case 1008: + return Wat2WasmMachine.call_1008(memory, instance, args); + case 1009: + return Wat2WasmMachine.call_1009(memory, instance, args); + case 1010: + return Wat2WasmMachine.call_1010(memory, instance, args); + case 1011: + return Wat2WasmMachine.call_1011(memory, instance, args); + case 1012: + return Wat2WasmMachine.call_1012(memory, instance, args); + case 1013: + return Wat2WasmMachine.call_1013(memory, instance, args); + case 1014: + return Wat2WasmMachine.call_1014(memory, instance, args); + case 1015: + return Wat2WasmMachine.call_1015(memory, instance, args); + case 1016: + return Wat2WasmMachine.call_1016(memory, instance, args); + case 1017: + return Wat2WasmMachine.call_1017(memory, instance, args); + case 1018: + return Wat2WasmMachine.call_1018(memory, instance, args); + case 1019: + return Wat2WasmMachine.call_1019(memory, instance, args); + case 1020: + return Wat2WasmMachine.call_1020(memory, instance, args); + case 1021: + return Wat2WasmMachine.call_1021(memory, instance, args); + case 1022: + return Wat2WasmMachine.call_1022(memory, instance, args); + case 1023: + return Wat2WasmMachine.call_1023(memory, instance, args); + case 1024: + return Wat2WasmMachine.call_1024(memory, instance, args); + case 1025: + return Wat2WasmMachine.call_1025(memory, instance, args); + case 1026: + return Wat2WasmMachine.call_1026(memory, instance, args); + case 1027: + return Wat2WasmMachine.call_1027(memory, instance, args); + case 1028: + return Wat2WasmMachine.call_1028(memory, instance, args); + case 1029: + return Wat2WasmMachine.call_1029(memory, instance, args); + case 1030: + return Wat2WasmMachine.call_1030(memory, instance, args); + case 1031: + return Wat2WasmMachine.call_1031(memory, instance, args); + case 1032: + return Wat2WasmMachine.call_1032(memory, instance, args); + case 1033: + return Wat2WasmMachine.call_1033(memory, instance, args); + case 1034: + return Wat2WasmMachine.call_1034(memory, instance, args); + case 1035: + return Wat2WasmMachine.call_1035(memory, instance, args); + case 1036: + return Wat2WasmMachine.call_1036(memory, instance, args); + case 1037: + return Wat2WasmMachine.call_1037(memory, instance, args); + case 1038: + return Wat2WasmMachine.call_1038(memory, instance, args); + case 1039: + return Wat2WasmMachine.call_1039(memory, instance, args); + case 1040: + return Wat2WasmMachine.call_1040(memory, instance, args); + case 1041: + return Wat2WasmMachine.call_1041(memory, instance, args); + case 1042: + return Wat2WasmMachine.call_1042(memory, instance, args); + case 1043: + return Wat2WasmMachine.call_1043(memory, instance, args); + case 1044: + return Wat2WasmMachine.call_1044(memory, instance, args); + case 1045: + return Wat2WasmMachine.call_1045(memory, instance, args); + case 1046: + return Wat2WasmMachine.call_1046(memory, instance, args); + case 1047: + return Wat2WasmMachine.call_1047(memory, instance, args); + case 1048: + return Wat2WasmMachine.call_1048(memory, instance, args); + case 1049: + return Wat2WasmMachine.call_1049(memory, instance, args); + case 1050: + return Wat2WasmMachine.call_1050(memory, instance, args); + case 1051: + return Wat2WasmMachine.call_1051(memory, instance, args); + case 1052: + return Wat2WasmMachine.call_1052(memory, instance, args); + case 1053: + return Wat2WasmMachine.call_1053(memory, instance, args); + case 1054: + return Wat2WasmMachine.call_1054(memory, instance, args); + case 1055: + return Wat2WasmMachine.call_1055(memory, instance, args); + case 1056: + return Wat2WasmMachine.call_1056(memory, instance, args); + case 1057: + return Wat2WasmMachine.call_1057(memory, instance, args); + case 1058: + return Wat2WasmMachine.call_1058(memory, instance, args); + case 1059: + return Wat2WasmMachine.call_1059(memory, instance, args); + case 1060: + return Wat2WasmMachine.call_1060(memory, instance, args); + case 1061: + return Wat2WasmMachine.call_1061(memory, instance, args); + case 1062: + return Wat2WasmMachine.call_1062(memory, instance, args); + case 1063: + return Wat2WasmMachine.call_1063(memory, instance, args); + case 1064: + return Wat2WasmMachine.call_1064(memory, instance, args); + case 1065: + return Wat2WasmMachine.call_1065(memory, instance, args); + case 1066: + return Wat2WasmMachine.call_1066(memory, instance, args); + case 1067: + return Wat2WasmMachine.call_1067(memory, instance, args); + case 1068: + return Wat2WasmMachine.call_1068(memory, instance, args); + case 1069: + return Wat2WasmMachine.call_1069(memory, instance, args); + case 1070: + return Wat2WasmMachine.call_1070(memory, instance, args); + case 1071: + return Wat2WasmMachine.call_1071(memory, instance, args); + case 1072: + return Wat2WasmMachine.call_1072(memory, instance, args); + case 1073: + return Wat2WasmMachine.call_1073(memory, instance, args); + case 1074: + return Wat2WasmMachine.call_1074(memory, instance, args); + case 1075: + return Wat2WasmMachine.call_1075(memory, instance, args); + case 1076: + return Wat2WasmMachine.call_1076(memory, instance, args); + case 1077: + return Wat2WasmMachine.call_1077(memory, instance, args); + case 1078: + return Wat2WasmMachine.call_1078(memory, instance, args); + case 1079: + return Wat2WasmMachine.call_1079(memory, instance, args); + case 1080: + return Wat2WasmMachine.call_1080(memory, instance, args); + case 1081: + return Wat2WasmMachine.call_1081(memory, instance, args); + case 1082: + return Wat2WasmMachine.call_1082(memory, instance, args); + case 1083: + return Wat2WasmMachine.call_1083(memory, instance, args); + case 1084: + return Wat2WasmMachine.call_1084(memory, instance, args); + case 1085: + return Wat2WasmMachine.call_1085(memory, instance, args); + case 1086: + return Wat2WasmMachine.call_1086(memory, instance, args); + case 1087: + return Wat2WasmMachine.call_1087(memory, instance, args); + case 1088: + return Wat2WasmMachine.call_1088(memory, instance, args); + case 1089: + return Wat2WasmMachine.call_1089(memory, instance, args); + case 1090: + return Wat2WasmMachine.call_1090(memory, instance, args); + case 1091: + return Wat2WasmMachine.call_1091(memory, instance, args); + case 1092: + return Wat2WasmMachine.call_1092(memory, instance, args); + case 1093: + return Wat2WasmMachine.call_1093(memory, instance, args); + case 1094: + return Wat2WasmMachine.call_1094(memory, instance, args); + case 1095: + return Wat2WasmMachine.call_1095(memory, instance, args); + case 1096: + return Wat2WasmMachine.call_1096(memory, instance, args); + case 1097: + return Wat2WasmMachine.call_1097(memory, instance, args); + case 1098: + return Wat2WasmMachine.call_1098(memory, instance, args); + case 1099: + return Wat2WasmMachine.call_1099(memory, instance, args); + case 1100: + return Wat2WasmMachine.call_1100(memory, instance, args); + case 1101: + return Wat2WasmMachine.call_1101(memory, instance, args); + case 1102: + return Wat2WasmMachine.call_1102(memory, instance, args); + case 1103: + return Wat2WasmMachine.call_1103(memory, instance, args); + case 1104: + return Wat2WasmMachine.call_1104(memory, instance, args); + case 1105: + return Wat2WasmMachine.call_1105(memory, instance, args); + case 1106: + return Wat2WasmMachine.call_1106(memory, instance, args); + case 1107: + return Wat2WasmMachine.call_1107(memory, instance, args); + case 1108: + return Wat2WasmMachine.call_1108(memory, instance, args); + case 1109: + return Wat2WasmMachine.call_1109(memory, instance, args); + case 1110: + return Wat2WasmMachine.call_1110(memory, instance, args); + case 1111: + return Wat2WasmMachine.call_1111(memory, instance, args); + case 1112: + return Wat2WasmMachine.call_1112(memory, instance, args); + case 1113: + return Wat2WasmMachine.call_1113(memory, instance, args); + case 1114: + return Wat2WasmMachine.call_1114(memory, instance, args); + case 1115: + return Wat2WasmMachine.call_1115(memory, instance, args); + case 1116: + return Wat2WasmMachine.call_1116(memory, instance, args); + case 1117: + return Wat2WasmMachine.call_1117(memory, instance, args); + case 1118: + return Wat2WasmMachine.call_1118(memory, instance, args); + case 1119: + return Wat2WasmMachine.call_1119(memory, instance, args); + case 1120: + return Wat2WasmMachine.call_1120(memory, instance, args); + case 1121: + return Wat2WasmMachine.call_1121(memory, instance, args); + case 1122: + return Wat2WasmMachine.call_1122(memory, instance, args); + case 1123: + return Wat2WasmMachine.call_1123(memory, instance, args); + case 1124: + return Wat2WasmMachine.call_1124(memory, instance, args); + case 1125: + return Wat2WasmMachine.call_1125(memory, instance, args); + case 1126: + return Wat2WasmMachine.call_1126(memory, instance, args); + case 1127: + return Wat2WasmMachine.call_1127(memory, instance, args); + case 1128: + return Wat2WasmMachine.call_1128(memory, instance, args); + case 1129: + return Wat2WasmMachine.call_1129(memory, instance, args); + case 1130: + return Wat2WasmMachine.call_1130(memory, instance, args); + case 1131: + return Wat2WasmMachine.call_1131(memory, instance, args); + case 1132: + return Wat2WasmMachine.call_1132(memory, instance, args); + case 1133: + return Wat2WasmMachine.call_1133(memory, instance, args); + case 1134: + return Wat2WasmMachine.call_1134(memory, instance, args); + case 1135: + return Wat2WasmMachine.call_1135(memory, instance, args); + case 1136: + return Wat2WasmMachine.call_1136(memory, instance, args); + case 1137: + return Wat2WasmMachine.call_1137(memory, instance, args); + case 1138: + return Wat2WasmMachine.call_1138(memory, instance, args); + case 1139: + return Wat2WasmMachine.call_1139(memory, instance, args); + case 1140: + return Wat2WasmMachine.call_1140(memory, instance, args); + case 1141: + return Wat2WasmMachine.call_1141(memory, instance, args); + case 1142: + return Wat2WasmMachine.call_1142(memory, instance, args); + case 1143: + return Wat2WasmMachine.call_1143(memory, instance, args); + case 1144: + return Wat2WasmMachine.call_1144(memory, instance, args); + case 1145: + return Wat2WasmMachine.call_1145(memory, instance, args); + case 1146: + return Wat2WasmMachine.call_1146(memory, instance, args); + case 1147: + return Wat2WasmMachine.call_1147(memory, instance, args); + case 1148: + return Wat2WasmMachine.call_1148(memory, instance, args); + case 1149: + return Wat2WasmMachine.call_1149(memory, instance, args); + case 1150: + return Wat2WasmMachine.call_1150(memory, instance, args); + case 1151: + return Wat2WasmMachine.call_1151(memory, instance, args); + case 1152: + return Wat2WasmMachine.call_1152(memory, instance, args); + case 1153: + return Wat2WasmMachine.call_1153(memory, instance, args); + case 1154: + return Wat2WasmMachine.call_1154(memory, instance, args); + case 1155: + return Wat2WasmMachine.call_1155(memory, instance, args); + case 1156: + return Wat2WasmMachine.call_1156(memory, instance, args); + case 1157: + return Wat2WasmMachine.call_1157(memory, instance, args); + case 1158: + return Wat2WasmMachine.call_1158(memory, instance, args); + case 1159: + return Wat2WasmMachine.call_1159(memory, instance, args); + case 1160: + return Wat2WasmMachine.call_1160(memory, instance, args); + case 1161: + return Wat2WasmMachine.call_1161(memory, instance, args); + case 1162: + return Wat2WasmMachine.call_1162(memory, instance, args); + case 1163: + return Wat2WasmMachine.call_1163(memory, instance, args); + case 1164: + return Wat2WasmMachine.call_1164(memory, instance, args); + case 1165: + return Wat2WasmMachine.call_1165(memory, instance, args); + case 1166: + return Wat2WasmMachine.call_1166(memory, instance, args); + case 1167: + return Wat2WasmMachine.call_1167(memory, instance, args); + case 1168: + return Wat2WasmMachine.call_1168(memory, instance, args); + case 1169: + return Wat2WasmMachine.call_1169(memory, instance, args); + case 1170: + return Wat2WasmMachine.call_1170(memory, instance, args); + case 1171: + return Wat2WasmMachine.call_1171(memory, instance, args); + case 1172: + return Wat2WasmMachine.call_1172(memory, instance, args); + case 1173: + return Wat2WasmMachine.call_1173(memory, instance, args); + case 1174: + return Wat2WasmMachine.call_1174(memory, instance, args); + case 1175: + return Wat2WasmMachine.call_1175(memory, instance, args); + case 1176: + return Wat2WasmMachine.call_1176(memory, instance, args); + case 1177: + return Wat2WasmMachine.call_1177(memory, instance, args); + case 1178: + return Wat2WasmMachine.call_1178(memory, instance, args); + case 1179: + return Wat2WasmMachine.call_1179(memory, instance, args); + case 1180: + return Wat2WasmMachine.call_1180(memory, instance, args); + case 1181: + return Wat2WasmMachine.call_1181(memory, instance, args); + case 1182: + return Wat2WasmMachine.call_1182(memory, instance, args); + case 1183: + return Wat2WasmMachine.call_1183(memory, instance, args); + case 1184: + return Wat2WasmMachine.call_1184(memory, instance, args); + case 1185: + return Wat2WasmMachine.call_1185(memory, instance, args); + case 1186: + return Wat2WasmMachine.call_1186(memory, instance, args); + case 1187: + return Wat2WasmMachine.call_1187(memory, instance, args); + case 1188: + return Wat2WasmMachine.call_1188(memory, instance, args); + case 1189: + return Wat2WasmMachine.call_1189(memory, instance, args); + case 1190: + return Wat2WasmMachine.call_1190(memory, instance, args); + case 1191: + return Wat2WasmMachine.call_1191(memory, instance, args); + case 1192: + return Wat2WasmMachine.call_1192(memory, instance, args); + case 1193: + return Wat2WasmMachine.call_1193(memory, instance, args); + case 1194: + return Wat2WasmMachine.call_1194(memory, instance, args); + case 1195: + return Wat2WasmMachine.call_1195(memory, instance, args); + case 1196: + return Wat2WasmMachine.call_1196(memory, instance, args); + case 1197: + return Wat2WasmMachine.call_1197(memory, instance, args); + case 1198: + return Wat2WasmMachine.call_1198(memory, instance, args); + case 1199: + return Wat2WasmMachine.call_1199(memory, instance, args); + case 1200: + return Wat2WasmMachine.call_1200(memory, instance, args); + case 1201: + return Wat2WasmMachine.call_1201(memory, instance, args); + case 1202: + return Wat2WasmMachine.call_1202(memory, instance, args); + case 1203: + return Wat2WasmMachine.call_1203(memory, instance, args); + case 1204: + return Wat2WasmMachine.call_1204(memory, instance, args); + case 1205: + return Wat2WasmMachine.call_1205(memory, instance, args); + case 1206: + return Wat2WasmMachine.call_1206(memory, instance, args); + case 1207: + return Wat2WasmMachine.call_1207(memory, instance, args); + case 1208: + return Wat2WasmMachine.call_1208(memory, instance, args); + case 1209: + return Wat2WasmMachine.call_1209(memory, instance, args); + case 1210: + return Wat2WasmMachine.call_1210(memory, instance, args); + case 1211: + return Wat2WasmMachine.call_1211(memory, instance, args); + case 1212: + return Wat2WasmMachine.call_1212(memory, instance, args); + case 1213: + return Wat2WasmMachine.call_1213(memory, instance, args); + case 1214: + return Wat2WasmMachine.call_1214(memory, instance, args); + case 1215: + return Wat2WasmMachine.call_1215(memory, instance, args); + case 1216: + return Wat2WasmMachine.call_1216(memory, instance, args); + case 1217: + return Wat2WasmMachine.call_1217(memory, instance, args); + case 1218: + return Wat2WasmMachine.call_1218(memory, instance, args); + case 1219: + return Wat2WasmMachine.call_1219(memory, instance, args); + case 1220: + return Wat2WasmMachine.call_1220(memory, instance, args); + case 1221: + return Wat2WasmMachine.call_1221(memory, instance, args); + case 1222: + return Wat2WasmMachine.call_1222(memory, instance, args); + case 1223: + return Wat2WasmMachine.call_1223(memory, instance, args); + case 1224: + return Wat2WasmMachine.call_1224(memory, instance, args); + case 1225: + return Wat2WasmMachine.call_1225(memory, instance, args); + case 1226: + return Wat2WasmMachine.call_1226(memory, instance, args); + case 1227: + return Wat2WasmMachine.call_1227(memory, instance, args); + case 1228: + return Wat2WasmMachine.call_1228(memory, instance, args); + case 1229: + return Wat2WasmMachine.call_1229(memory, instance, args); + case 1230: + return Wat2WasmMachine.call_1230(memory, instance, args); + case 1231: + return Wat2WasmMachine.call_1231(memory, instance, args); + case 1232: + return Wat2WasmMachine.call_1232(memory, instance, args); + case 1233: + return Wat2WasmMachine.call_1233(memory, instance, args); + case 1234: + return Wat2WasmMachine.call_1234(memory, instance, args); + case 1235: + return Wat2WasmMachine.call_1235(memory, instance, args); + case 1236: + return Wat2WasmMachine.call_1236(memory, instance, args); + case 1237: + return Wat2WasmMachine.call_1237(memory, instance, args); + case 1238: + return Wat2WasmMachine.call_1238(memory, instance, args); + case 1239: + return Wat2WasmMachine.call_1239(memory, instance, args); + case 1240: + return Wat2WasmMachine.call_1240(memory, instance, args); + case 1241: + return Wat2WasmMachine.call_1241(memory, instance, args); + case 1242: + return Wat2WasmMachine.call_1242(memory, instance, args); + case 1243: + return Wat2WasmMachine.call_1243(memory, instance, args); + case 1244: + return Wat2WasmMachine.call_1244(memory, instance, args); + case 1245: + return Wat2WasmMachine.call_1245(memory, instance, args); + case 1246: + return Wat2WasmMachine.call_1246(memory, instance, args); + case 1247: + return Wat2WasmMachine.call_1247(memory, instance, args); + case 1248: + return Wat2WasmMachine.call_1248(memory, instance, args); + case 1249: + return Wat2WasmMachine.call_1249(memory, instance, args); + case 1250: + return Wat2WasmMachine.call_1250(memory, instance, args); + case 1251: + return Wat2WasmMachine.call_1251(memory, instance, args); + case 1252: + return Wat2WasmMachine.call_1252(memory, instance, args); + case 1253: + return Wat2WasmMachine.call_1253(memory, instance, args); + case 1254: + return Wat2WasmMachine.call_1254(memory, instance, args); + case 1255: + return Wat2WasmMachine.call_1255(memory, instance, args); + case 1256: + return Wat2WasmMachine.call_1256(memory, instance, args); + case 1257: + return Wat2WasmMachine.call_1257(memory, instance, args); + case 1258: + return Wat2WasmMachine.call_1258(memory, instance, args); + case 1259: + return Wat2WasmMachine.call_1259(memory, instance, args); + case 1260: + return Wat2WasmMachine.call_1260(memory, instance, args); + case 1261: + return Wat2WasmMachine.call_1261(memory, instance, args); + case 1262: + return Wat2WasmMachine.call_1262(memory, instance, args); + case 1263: + return Wat2WasmMachine.call_1263(memory, instance, args); + case 1264: + return Wat2WasmMachine.call_1264(memory, instance, args); + case 1265: + return Wat2WasmMachine.call_1265(memory, instance, args); + case 1266: + return Wat2WasmMachine.call_1266(memory, instance, args); + case 1267: + return Wat2WasmMachine.call_1267(memory, instance, args); + case 1268: + return Wat2WasmMachine.call_1268(memory, instance, args); + case 1269: + return Wat2WasmMachine.call_1269(memory, instance, args); + case 1270: + return Wat2WasmMachine.call_1270(memory, instance, args); + case 1271: + return Wat2WasmMachine.call_1271(memory, instance, args); + case 1272: + return Wat2WasmMachine.call_1272(memory, instance, args); + case 1273: + return Wat2WasmMachine.call_1273(memory, instance, args); + case 1274: + return Wat2WasmMachine.call_1274(memory, instance, args); + case 1275: + return Wat2WasmMachine.call_1275(memory, instance, args); + case 1276: + return Wat2WasmMachine.call_1276(memory, instance, args); + case 1277: + return Wat2WasmMachine.call_1277(memory, instance, args); + case 1278: + return Wat2WasmMachine.call_1278(memory, instance, args); + case 1279: + return Wat2WasmMachine.call_1279(memory, instance, args); + case 1280: + return Wat2WasmMachine.call_1280(memory, instance, args); + case 1281: + return Wat2WasmMachine.call_1281(memory, instance, args); + case 1282: + return Wat2WasmMachine.call_1282(memory, instance, args); + case 1283: + return Wat2WasmMachine.call_1283(memory, instance, args); + case 1284: + return Wat2WasmMachine.call_1284(memory, instance, args); + case 1285: + return Wat2WasmMachine.call_1285(memory, instance, args); + case 1286: + return Wat2WasmMachine.call_1286(memory, instance, args); + case 1287: + return Wat2WasmMachine.call_1287(memory, instance, args); + case 1288: + return Wat2WasmMachine.call_1288(memory, instance, args); + case 1289: + return Wat2WasmMachine.call_1289(memory, instance, args); + case 1290: + return Wat2WasmMachine.call_1290(memory, instance, args); + case 1291: + return Wat2WasmMachine.call_1291(memory, instance, args); + case 1292: + return Wat2WasmMachine.call_1292(memory, instance, args); + case 1293: + return Wat2WasmMachine.call_1293(memory, instance, args); + case 1294: + return Wat2WasmMachine.call_1294(memory, instance, args); + case 1295: + return Wat2WasmMachine.call_1295(memory, instance, args); + case 1296: + return Wat2WasmMachine.call_1296(memory, instance, args); + case 1297: + return Wat2WasmMachine.call_1297(memory, instance, args); + case 1298: + return Wat2WasmMachine.call_1298(memory, instance, args); + case 1299: + return Wat2WasmMachine.call_1299(memory, instance, args); + case 1300: + return Wat2WasmMachine.call_1300(memory, instance, args); + case 1301: + return Wat2WasmMachine.call_1301(memory, instance, args); + case 1302: + return Wat2WasmMachine.call_1302(memory, instance, args); + case 1303: + return Wat2WasmMachine.call_1303(memory, instance, args); + case 1304: + return Wat2WasmMachine.call_1304(memory, instance, args); + case 1305: + return Wat2WasmMachine.call_1305(memory, instance, args); + case 1306: + return Wat2WasmMachine.call_1306(memory, instance, args); + case 1307: + return Wat2WasmMachine.call_1307(memory, instance, args); + case 1308: + return Wat2WasmMachine.call_1308(memory, instance, args); + case 1309: + return Wat2WasmMachine.call_1309(memory, instance, args); + case 1310: + return Wat2WasmMachine.call_1310(memory, instance, args); + case 1311: + return Wat2WasmMachine.call_1311(memory, instance, args); + case 1312: + return Wat2WasmMachine.call_1312(memory, instance, args); + case 1313: + return Wat2WasmMachine.call_1313(memory, instance, args); + case 1314: + return Wat2WasmMachine.call_1314(memory, instance, args); + case 1315: + return Wat2WasmMachine.call_1315(memory, instance, args); + case 1316: + return Wat2WasmMachine.call_1316(memory, instance, args); + case 1317: + return Wat2WasmMachine.call_1317(memory, instance, args); + case 1318: + return Wat2WasmMachine.call_1318(memory, instance, args); + case 1319: + return Wat2WasmMachine.call_1319(memory, instance, args); + case 1320: + return Wat2WasmMachine.call_1320(memory, instance, args); + case 1321: + return Wat2WasmMachine.call_1321(memory, instance, args); + case 1322: + return Wat2WasmMachine.call_1322(memory, instance, args); + case 1323: + return Wat2WasmMachine.call_1323(memory, instance, args); + case 1324: + return Wat2WasmMachine.call_1324(memory, instance, args); + case 1325: + return Wat2WasmMachine.call_1325(memory, instance, args); + case 1326: + return Wat2WasmMachine.call_1326(memory, instance, args); + case 1327: + return Wat2WasmMachine.call_1327(memory, instance, args); + case 1328: + return Wat2WasmMachine.call_1328(memory, instance, args); + case 1329: + return Wat2WasmMachine.call_1329(memory, instance, args); + case 1330: + return Wat2WasmMachine.call_1330(memory, instance, args); + case 1331: + return Wat2WasmMachine.call_1331(memory, instance, args); + case 1332: + return Wat2WasmMachine.call_1332(memory, instance, args); + case 1333: + return Wat2WasmMachine.call_1333(memory, instance, args); + case 1334: + return Wat2WasmMachine.call_1334(memory, instance, args); + case 1335: + return Wat2WasmMachine.call_1335(memory, instance, args); + case 1336: + return Wat2WasmMachine.call_1336(memory, instance, args); + case 1337: + return Wat2WasmMachine.call_1337(memory, instance, args); + case 1338: + return Wat2WasmMachine.call_1338(memory, instance, args); + case 1339: + return Wat2WasmMachine.call_1339(memory, instance, args); + case 1340: + return Wat2WasmMachine.call_1340(memory, instance, args); + case 1341: + return Wat2WasmMachine.call_1341(memory, instance, args); + case 1342: + return Wat2WasmMachine.call_1342(memory, instance, args); + case 1343: + return Wat2WasmMachine.call_1343(memory, instance, args); + case 1344: + return Wat2WasmMachine.call_1344(memory, instance, args); + case 1345: + return Wat2WasmMachine.call_1345(memory, instance, args); + case 1346: + return Wat2WasmMachine.call_1346(memory, instance, args); + case 1347: + return Wat2WasmMachine.call_1347(memory, instance, args); + case 1348: + return Wat2WasmMachine.call_1348(memory, instance, args); + case 1349: + return Wat2WasmMachine.call_1349(memory, instance, args); + case 1350: + return Wat2WasmMachine.call_1350(memory, instance, args); + case 1351: + return Wat2WasmMachine.call_1351(memory, instance, args); + case 1352: + return Wat2WasmMachine.call_1352(memory, instance, args); + case 1353: + return Wat2WasmMachine.call_1353(memory, instance, args); + case 1354: + return Wat2WasmMachine.call_1354(memory, instance, args); + case 1355: + return Wat2WasmMachine.call_1355(memory, instance, args); + case 1356: + return Wat2WasmMachine.call_1356(memory, instance, args); + case 1357: + return Wat2WasmMachine.call_1357(memory, instance, args); + case 1358: + return Wat2WasmMachine.call_1358(memory, instance, args); + case 1359: + return Wat2WasmMachine.call_1359(memory, instance, args); + case 1360: + return Wat2WasmMachine.call_1360(memory, instance, args); + case 1361: + return Wat2WasmMachine.call_1361(memory, instance, args); + case 1362: + return Wat2WasmMachine.call_1362(memory, instance, args); + case 1363: + return Wat2WasmMachine.call_1363(memory, instance, args); + case 1364: + return Wat2WasmMachine.call_1364(memory, instance, args); + case 1365: + return Wat2WasmMachine.call_1365(memory, instance, args); + case 1366: + return Wat2WasmMachine.call_1366(memory, instance, args); + case 1367: + return Wat2WasmMachine.call_1367(memory, instance, args); + case 1368: + return Wat2WasmMachine.call_1368(memory, instance, args); + case 1369: + return Wat2WasmMachine.call_1369(memory, instance, args); + case 1370: + return Wat2WasmMachine.call_1370(memory, instance, args); + case 1371: + return Wat2WasmMachine.call_1371(memory, instance, args); + case 1372: + return Wat2WasmMachine.call_1372(memory, instance, args); + case 1373: + return Wat2WasmMachine.call_1373(memory, instance, args); + case 1374: + return Wat2WasmMachine.call_1374(memory, instance, args); + case 1375: + return Wat2WasmMachine.call_1375(memory, instance, args); + case 1376: + return Wat2WasmMachine.call_1376(memory, instance, args); + case 1377: + return Wat2WasmMachine.call_1377(memory, instance, args); + case 1378: + return Wat2WasmMachine.call_1378(memory, instance, args); + case 1379: + return Wat2WasmMachine.call_1379(memory, instance, args); + case 1380: + return Wat2WasmMachine.call_1380(memory, instance, args); + case 1381: + return Wat2WasmMachine.call_1381(memory, instance, args); + case 1382: + return Wat2WasmMachine.call_1382(memory, instance, args); + case 1383: + return Wat2WasmMachine.call_1383(memory, instance, args); + case 1384: + return Wat2WasmMachine.call_1384(memory, instance, args); + case 1385: + return Wat2WasmMachine.call_1385(memory, instance, args); + case 1386: + return Wat2WasmMachine.call_1386(memory, instance, args); + case 1387: + return Wat2WasmMachine.call_1387(memory, instance, args); + case 1388: + return Wat2WasmMachine.call_1388(memory, instance, args); + case 1389: + return Wat2WasmMachine.call_1389(memory, instance, args); + case 1390: + return Wat2WasmMachine.call_1390(memory, instance, args); + case 1391: + return Wat2WasmMachine.call_1391(memory, instance, args); + case 1392: + return Wat2WasmMachine.call_1392(memory, instance, args); + case 1393: + return Wat2WasmMachine.call_1393(memory, instance, args); + case 1394: + return Wat2WasmMachine.call_1394(memory, instance, args); + case 1395: + return Wat2WasmMachine.call_1395(memory, instance, args); + case 1396: + return Wat2WasmMachine.call_1396(memory, instance, args); + case 1397: + return Wat2WasmMachine.call_1397(memory, instance, args); + case 1398: + return Wat2WasmMachine.call_1398(memory, instance, args); + case 1399: + return Wat2WasmMachine.call_1399(memory, instance, args); + case 1400: + return Wat2WasmMachine.call_1400(memory, instance, args); + case 1401: + return Wat2WasmMachine.call_1401(memory, instance, args); + case 1402: + return Wat2WasmMachine.call_1402(memory, instance, args); + case 1403: + return Wat2WasmMachine.call_1403(memory, instance, args); + case 1404: + return Wat2WasmMachine.call_1404(memory, instance, args); + case 1405: + return Wat2WasmMachine.call_1405(memory, instance, args); + case 1406: + return Wat2WasmMachine.call_1406(memory, instance, args); + case 1407: + return Wat2WasmMachine.call_1407(memory, instance, args); + case 1408: + return Wat2WasmMachine.call_1408(memory, instance, args); + case 1409: + return Wat2WasmMachine.call_1409(memory, instance, args); + case 1410: + return Wat2WasmMachine.call_1410(memory, instance, args); + case 1411: + return Wat2WasmMachine.call_1411(memory, instance, args); + case 1412: + return Wat2WasmMachine.call_1412(memory, instance, args); + case 1413: + return Wat2WasmMachine.call_1413(memory, instance, args); + case 1414: + return Wat2WasmMachine.call_1414(memory, instance, args); + case 1415: + return Wat2WasmMachine.call_1415(memory, instance, args); + case 1416: + return Wat2WasmMachine.call_1416(memory, instance, args); + case 1417: + return Wat2WasmMachine.call_1417(memory, instance, args); + case 1418: + return Wat2WasmMachine.call_1418(memory, instance, args); + case 1419: + return Wat2WasmMachine.call_1419(memory, instance, args); + case 1420: + return Wat2WasmMachine.call_1420(memory, instance, args); + case 1421: + return Wat2WasmMachine.call_1421(memory, instance, args); + case 1422: + return Wat2WasmMachine.call_1422(memory, instance, args); + case 1423: + return Wat2WasmMachine.call_1423(memory, instance, args); + case 1424: + return Wat2WasmMachine.call_1424(memory, instance, args); + case 1425: + return Wat2WasmMachine.call_1425(memory, instance, args); + case 1426: + return Wat2WasmMachine.call_1426(memory, instance, args); + case 1427: + return Wat2WasmMachine.call_1427(memory, instance, args); + case 1428: + return Wat2WasmMachine.call_1428(memory, instance, args); + case 1429: + return Wat2WasmMachine.call_1429(memory, instance, args); + case 1430: + return Wat2WasmMachine.call_1430(memory, instance, args); + case 1431: + return Wat2WasmMachine.call_1431(memory, instance, args); + case 1432: + return Wat2WasmMachine.call_1432(memory, instance, args); + case 1433: + return Wat2WasmMachine.call_1433(memory, instance, args); + case 1434: + return Wat2WasmMachine.call_1434(memory, instance, args); + case 1435: + return Wat2WasmMachine.call_1435(memory, instance, args); + case 1436: + return Wat2WasmMachine.call_1436(memory, instance, args); + case 1437: + return Wat2WasmMachine.call_1437(memory, instance, args); + case 1438: + return Wat2WasmMachine.call_1438(memory, instance, args); + case 1439: + return Wat2WasmMachine.call_1439(memory, instance, args); + case 1440: + return Wat2WasmMachine.call_1440(memory, instance, args); + case 1441: + return Wat2WasmMachine.call_1441(memory, instance, args); + case 1442: + return Wat2WasmMachine.call_1442(memory, instance, args); + case 1443: + return Wat2WasmMachine.call_1443(memory, instance, args); + case 1444: + return Wat2WasmMachine.call_1444(memory, instance, args); + case 1445: + return Wat2WasmMachine.call_1445(memory, instance, args); + case 1446: + return Wat2WasmMachine.call_1446(memory, instance, args); + case 1447: + return Wat2WasmMachine.call_1447(memory, instance, args); + case 1448: + return Wat2WasmMachine.call_1448(memory, instance, args); + case 1449: + return Wat2WasmMachine.call_1449(memory, instance, args); + case 1450: + return Wat2WasmMachine.call_1450(memory, instance, args); + case 1451: + return Wat2WasmMachine.call_1451(memory, instance, args); + case 1452: + return Wat2WasmMachine.call_1452(memory, instance, args); + case 1453: + return Wat2WasmMachine.call_1453(memory, instance, args); + case 1454: + return Wat2WasmMachine.call_1454(memory, instance, args); + case 1455: + return Wat2WasmMachine.call_1455(memory, instance, args); + case 1456: + return Wat2WasmMachine.call_1456(memory, instance, args); + case 1457: + return Wat2WasmMachine.call_1457(memory, instance, args); + case 1458: + return Wat2WasmMachine.call_1458(memory, instance, args); + case 1459: + return Wat2WasmMachine.call_1459(memory, instance, args); + case 1460: + return Wat2WasmMachine.call_1460(memory, instance, args); + case 1461: + return Wat2WasmMachine.call_1461(memory, instance, args); + case 1462: + return Wat2WasmMachine.call_1462(memory, instance, args); + case 1463: + return Wat2WasmMachine.call_1463(memory, instance, args); + case 1464: + return Wat2WasmMachine.call_1464(memory, instance, args); + case 1465: + return Wat2WasmMachine.call_1465(memory, instance, args); + case 1466: + return Wat2WasmMachine.call_1466(memory, instance, args); + case 1467: + return Wat2WasmMachine.call_1467(memory, instance, args); + case 1468: + return Wat2WasmMachine.call_1468(memory, instance, args); + case 1469: + return Wat2WasmMachine.call_1469(memory, instance, args); + case 1470: + return Wat2WasmMachine.call_1470(memory, instance, args); + case 1471: + return Wat2WasmMachine.call_1471(memory, instance, args); + case 1472: + return Wat2WasmMachine.call_1472(memory, instance, args); + case 1473: + return Wat2WasmMachine.call_1473(memory, instance, args); + case 1474: + return Wat2WasmMachine.call_1474(memory, instance, args); + case 1475: + return Wat2WasmMachine.call_1475(memory, instance, args); + case 1476: + return Wat2WasmMachine.call_1476(memory, instance, args); + case 1477: + return Wat2WasmMachine.call_1477(memory, instance, args); + case 1478: + return Wat2WasmMachine.call_1478(memory, instance, args); + case 1479: + return Wat2WasmMachine.call_1479(memory, instance, args); + case 1480: + return Wat2WasmMachine.call_1480(memory, instance, args); + case 1481: + return Wat2WasmMachine.call_1481(memory, instance, args); + case 1482: + return Wat2WasmMachine.call_1482(memory, instance, args); + case 1483: + return Wat2WasmMachine.call_1483(memory, instance, args); + case 1484: + return Wat2WasmMachine.call_1484(memory, instance, args); + case 1485: + return Wat2WasmMachine.call_1485(memory, instance, args); + case 1486: + return Wat2WasmMachine.call_1486(memory, instance, args); + case 1487: + return Wat2WasmMachine.call_1487(memory, instance, args); + case 1488: + return Wat2WasmMachine.call_1488(memory, instance, args); + case 1489: + return Wat2WasmMachine.call_1489(memory, instance, args); + case 1490: + return Wat2WasmMachine.call_1490(memory, instance, args); + case 1491: + return Wat2WasmMachine.call_1491(memory, instance, args); + case 1492: + return Wat2WasmMachine.call_1492(memory, instance, args); + case 1493: + return Wat2WasmMachine.call_1493(memory, instance, args); + case 1494: + return Wat2WasmMachine.call_1494(memory, instance, args); + case 1495: + return Wat2WasmMachine.call_1495(memory, instance, args); + case 1496: + return Wat2WasmMachine.call_1496(memory, instance, args); + case 1497: + return Wat2WasmMachine.call_1497(memory, instance, args); + case 1498: + return Wat2WasmMachine.call_1498(memory, instance, args); + case 1499: + return Wat2WasmMachine.call_1499(memory, instance, args); + case 1500: + return Wat2WasmMachine.call_1500(memory, instance, args); + case 1501: + return Wat2WasmMachine.call_1501(memory, instance, args); + case 1502: + return Wat2WasmMachine.call_1502(memory, instance, args); + case 1503: + return Wat2WasmMachine.call_1503(memory, instance, args); + case 1504: + return Wat2WasmMachine.call_1504(memory, instance, args); + case 1505: + return Wat2WasmMachine.call_1505(memory, instance, args); + case 1506: + return Wat2WasmMachine.call_1506(memory, instance, args); + case 1507: + return Wat2WasmMachine.call_1507(memory, instance, args); + case 1508: + return Wat2WasmMachine.call_1508(memory, instance, args); + case 1509: + return Wat2WasmMachine.call_1509(memory, instance, args); + case 1510: + return Wat2WasmMachine.call_1510(memory, instance, args); + case 1511: + return Wat2WasmMachine.call_1511(memory, instance, args); + case 1512: + return Wat2WasmMachine.call_1512(memory, instance, args); + case 1513: + return Wat2WasmMachine.call_1513(memory, instance, args); + case 1514: + return Wat2WasmMachine.call_1514(memory, instance, args); + case 1515: + return Wat2WasmMachine.call_1515(memory, instance, args); + case 1516: + return Wat2WasmMachine.call_1516(memory, instance, args); + case 1517: + return Wat2WasmMachine.call_1517(memory, instance, args); + case 1518: + return Wat2WasmMachine.call_1518(memory, instance, args); + case 1519: + return Wat2WasmMachine.call_1519(memory, instance, args); + case 1520: + return Wat2WasmMachine.call_1520(memory, instance, args); + case 1521: + return Wat2WasmMachine.call_1521(memory, instance, args); + case 1522: + return Wat2WasmMachine.call_1522(memory, instance, args); + case 1523: + return Wat2WasmMachine.call_1523(memory, instance, args); + case 1524: + return Wat2WasmMachine.call_1524(memory, instance, args); + case 1525: + return Wat2WasmMachine.call_1525(memory, instance, args); + case 1526: + return Wat2WasmMachine.call_1526(memory, instance, args); + case 1527: + return Wat2WasmMachine.call_1527(memory, instance, args); + case 1528: + return Wat2WasmMachine.call_1528(memory, instance, args); + case 1529: + return Wat2WasmMachine.call_1529(memory, instance, args); + case 1530: + return Wat2WasmMachine.call_1530(memory, instance, args); + case 1531: + return Wat2WasmMachine.call_1531(memory, instance, args); + case 1532: + return Wat2WasmMachine.call_1532(memory, instance, args); + case 1533: + return Wat2WasmMachine.call_1533(memory, instance, args); + case 1534: + return Wat2WasmMachine.call_1534(memory, instance, args); + case 1535: + return Wat2WasmMachine.call_1535(memory, instance, args); + case 1536: + return Wat2WasmMachine.call_1536(memory, instance, args); + case 1537: + return Wat2WasmMachine.call_1537(memory, instance, args); + case 1538: + return Wat2WasmMachine.call_1538(memory, instance, args); + case 1539: + return Wat2WasmMachine.call_1539(memory, instance, args); + case 1540: + return Wat2WasmMachine.call_1540(memory, instance, args); + case 1541: + return Wat2WasmMachine.call_1541(memory, instance, args); + case 1542: + return Wat2WasmMachine.call_1542(memory, instance, args); + case 1543: + return Wat2WasmMachine.call_1543(memory, instance, args); + case 1544: + return Wat2WasmMachine.call_1544(memory, instance, args); + case 1545: + return Wat2WasmMachine.call_1545(memory, instance, args); + case 1546: + return Wat2WasmMachine.call_1546(memory, instance, args); + case 1547: + return Wat2WasmMachine.call_1547(memory, instance, args); + case 1548: + return Wat2WasmMachine.call_1548(memory, instance, args); + case 1549: + return Wat2WasmMachine.call_1549(memory, instance, args); + case 1550: + return Wat2WasmMachine.call_1550(memory, instance, args); + case 1551: + return Wat2WasmMachine.call_1551(memory, instance, args); + case 1552: + return Wat2WasmMachine.call_1552(memory, instance, args); + case 1553: + return Wat2WasmMachine.call_1553(memory, instance, args); + case 1554: + return Wat2WasmMachine.call_1554(memory, instance, args); + case 1555: + return Wat2WasmMachine.call_1555(memory, instance, args); + case 1556: + return Wat2WasmMachine.call_1556(memory, instance, args); + case 1557: + return Wat2WasmMachine.call_1557(memory, instance, args); + case 1558: + return Wat2WasmMachine.call_1558(memory, instance, args); + case 1559: + return Wat2WasmMachine.call_1559(memory, instance, args); + case 1560: + return Wat2WasmMachine.call_1560(memory, instance, args); + case 1561: + return Wat2WasmMachine.call_1561(memory, instance, args); + case 1562: + return Wat2WasmMachine.call_1562(memory, instance, args); + case 1563: + return Wat2WasmMachine.call_1563(memory, instance, args); + case 1564: + return Wat2WasmMachine.call_1564(memory, instance, args); + case 1565: + return Wat2WasmMachine.call_1565(memory, instance, args); + case 1566: + return Wat2WasmMachine.call_1566(memory, instance, args); + case 1567: + return Wat2WasmMachine.call_1567(memory, instance, args); + case 1568: + return Wat2WasmMachine.call_1568(memory, instance, args); + case 1569: + return Wat2WasmMachine.call_1569(memory, instance, args); + case 1570: + return Wat2WasmMachine.call_1570(memory, instance, args); + case 1571: + return Wat2WasmMachine.call_1571(memory, instance, args); + case 1572: + return Wat2WasmMachine.call_1572(memory, instance, args); + case 1573: + return Wat2WasmMachine.call_1573(memory, instance, args); + case 1574: + return Wat2WasmMachine.call_1574(memory, instance, args); + case 1575: + return Wat2WasmMachine.call_1575(memory, instance, args); + case 1576: + return Wat2WasmMachine.call_1576(memory, instance, args); + case 1577: + return Wat2WasmMachine.call_1577(memory, instance, args); + case 1578: + return Wat2WasmMachine.call_1578(memory, instance, args); + case 1579: + return Wat2WasmMachine.call_1579(memory, instance, args); + case 1580: + return Wat2WasmMachine.call_1580(memory, instance, args); + case 1581: + return Wat2WasmMachine.call_1581(memory, instance, args); + case 1582: + return Wat2WasmMachine.call_1582(memory, instance, args); + case 1583: + return Wat2WasmMachine.call_1583(memory, instance, args); + case 1584: + return Wat2WasmMachine.call_1584(memory, instance, args); + case 1585: + return Wat2WasmMachine.call_1585(memory, instance, args); + case 1586: + return Wat2WasmMachine.call_1586(memory, instance, args); + case 1587: + return Wat2WasmMachine.call_1587(memory, instance, args); + case 1588: + return Wat2WasmMachine.call_1588(memory, instance, args); + case 1589: + return Wat2WasmMachine.call_1589(memory, instance, args); + case 1590: + return Wat2WasmMachine.call_1590(memory, instance, args); + case 1591: + return Wat2WasmMachine.call_1591(memory, instance, args); + case 1592: + return Wat2WasmMachine.call_1592(memory, instance, args); + case 1593: + return Wat2WasmMachine.call_1593(memory, instance, args); + case 1594: + return Wat2WasmMachine.call_1594(memory, instance, args); + case 1595: + return Wat2WasmMachine.call_1595(memory, instance, args); + case 1596: + return Wat2WasmMachine.call_1596(memory, instance, args); + case 1597: + return Wat2WasmMachine.call_1597(memory, instance, args); + case 1598: + return Wat2WasmMachine.call_1598(memory, instance, args); + case 1599: + return Wat2WasmMachine.call_1599(memory, instance, args); + case 1600: + return Wat2WasmMachine.call_1600(memory, instance, args); + case 1601: + return Wat2WasmMachine.call_1601(memory, instance, args); + case 1602: + return Wat2WasmMachine.call_1602(memory, instance, args); + case 1603: + return Wat2WasmMachine.call_1603(memory, instance, args); + case 1604: + return Wat2WasmMachine.call_1604(memory, instance, args); + case 1605: + return Wat2WasmMachine.call_1605(memory, instance, args); + case 1606: + return Wat2WasmMachine.call_1606(memory, instance, args); + case 1607: + return Wat2WasmMachine.call_1607(memory, instance, args); + case 1608: + return Wat2WasmMachine.call_1608(memory, instance, args); + case 1609: + return Wat2WasmMachine.call_1609(memory, instance, args); + case 1610: + return Wat2WasmMachine.call_1610(memory, instance, args); + case 1611: + return Wat2WasmMachine.call_1611(memory, instance, args); + case 1612: + return Wat2WasmMachine.call_1612(memory, instance, args); + case 1613: + return Wat2WasmMachine.call_1613(memory, instance, args); + case 1614: + return Wat2WasmMachine.call_1614(memory, instance, args); + case 1615: + return Wat2WasmMachine.call_1615(memory, instance, args); + case 1616: + return Wat2WasmMachine.call_1616(memory, instance, args); + case 1617: + return Wat2WasmMachine.call_1617(memory, instance, args); + case 1618: + return Wat2WasmMachine.call_1618(memory, instance, args); + case 1619: + return Wat2WasmMachine.call_1619(memory, instance, args); + case 1620: + return Wat2WasmMachine.call_1620(memory, instance, args); + case 1621: + return Wat2WasmMachine.call_1621(memory, instance, args); + case 1622: + return Wat2WasmMachine.call_1622(memory, instance, args); + case 1623: + return Wat2WasmMachine.call_1623(memory, instance, args); + case 1624: + return Wat2WasmMachine.call_1624(memory, instance, args); + case 1625: + return Wat2WasmMachine.call_1625(memory, instance, args); + case 1626: + return Wat2WasmMachine.call_1626(memory, instance, args); + case 1627: + return Wat2WasmMachine.call_1627(memory, instance, args); + case 1628: + return Wat2WasmMachine.call_1628(memory, instance, args); + case 1629: + return Wat2WasmMachine.call_1629(memory, instance, args); + case 1630: + return Wat2WasmMachine.call_1630(memory, instance, args); + case 1631: + return Wat2WasmMachine.call_1631(memory, instance, args); + case 1632: + return Wat2WasmMachine.call_1632(memory, instance, args); + case 1633: + return Wat2WasmMachine.call_1633(memory, instance, args); + case 1634: + return Wat2WasmMachine.call_1634(memory, instance, args); + case 1635: + return Wat2WasmMachine.call_1635(memory, instance, args); + case 1636: + return Wat2WasmMachine.call_1636(memory, instance, args); + case 1637: + return Wat2WasmMachine.call_1637(memory, instance, args); + case 1638: + return Wat2WasmMachine.call_1638(memory, instance, args); + case 1639: + return Wat2WasmMachine.call_1639(memory, instance, args); + case 1640: + return Wat2WasmMachine.call_1640(memory, instance, args); + case 1641: + return Wat2WasmMachine.call_1641(memory, instance, args); + case 1642: + return Wat2WasmMachine.call_1642(memory, instance, args); + case 1643: + return Wat2WasmMachine.call_1643(memory, instance, args); + case 1644: + return Wat2WasmMachine.call_1644(memory, instance, args); + case 1645: + return Wat2WasmMachine.call_1645(memory, instance, args); + case 1646: + return Wat2WasmMachine.call_1646(memory, instance, args); + case 1647: + return Wat2WasmMachine.call_1647(memory, instance, args); + case 1648: + return Wat2WasmMachine.call_1648(memory, instance, args); + case 1649: + return Wat2WasmMachine.call_1649(memory, instance, args); + case 1650: + return Wat2WasmMachine.call_1650(memory, instance, args); + case 1651: + return Wat2WasmMachine.call_1651(memory, instance, args); + case 1652: + return Wat2WasmMachine.call_1652(memory, instance, args); + case 1653: + return Wat2WasmMachine.call_1653(memory, instance, args); + case 1654: + return Wat2WasmMachine.call_1654(memory, instance, args); + case 1655: + return Wat2WasmMachine.call_1655(memory, instance, args); + case 1656: + return Wat2WasmMachine.call_1656(memory, instance, args); + case 1657: + return Wat2WasmMachine.call_1657(memory, instance, args); + case 1658: + return Wat2WasmMachine.call_1658(memory, instance, args); + case 1659: + return Wat2WasmMachine.call_1659(memory, instance, args); + case 1660: + return Wat2WasmMachine.call_1660(memory, instance, args); + case 1661: + return Wat2WasmMachine.call_1661(memory, instance, args); + case 1662: + return Wat2WasmMachine.call_1662(memory, instance, args); + case 1663: + return Wat2WasmMachine.call_1663(memory, instance, args); + case 1664: + return Wat2WasmMachine.call_1664(memory, instance, args); + case 1665: + return Wat2WasmMachine.call_1665(memory, instance, args); + case 1666: + return Wat2WasmMachine.call_1666(memory, instance, args); + case 1667: + return Wat2WasmMachine.call_1667(memory, instance, args); + case 1668: + return Wat2WasmMachine.call_1668(memory, instance, args); + case 1669: + return Wat2WasmMachine.call_1669(memory, instance, args); + case 1670: + return Wat2WasmMachine.call_1670(memory, instance, args); + case 1671: + return Wat2WasmMachine.call_1671(memory, instance, args); + case 1672: + return Wat2WasmMachine.call_1672(memory, instance, args); + case 1673: + return Wat2WasmMachine.call_1673(memory, instance, args); + case 1674: + return Wat2WasmMachine.call_1674(memory, instance, args); + case 1675: + return Wat2WasmMachine.call_1675(memory, instance, args); + case 1676: + return Wat2WasmMachine.call_1676(memory, instance, args); + case 1677: + return Wat2WasmMachine.call_1677(memory, instance, args); + case 1678: + return Wat2WasmMachine.call_1678(memory, instance, args); + case 1679: + return Wat2WasmMachine.call_1679(memory, instance, args); + case 1680: + return Wat2WasmMachine.call_1680(memory, instance, args); + case 1681: + return Wat2WasmMachine.call_1681(memory, instance, args); + case 1682: + return Wat2WasmMachine.call_1682(memory, instance, args); + case 1683: + return Wat2WasmMachine.call_1683(memory, instance, args); + case 1684: + return Wat2WasmMachine.call_1684(memory, instance, args); + case 1685: + return Wat2WasmMachine.call_1685(memory, instance, args); + case 1686: + return Wat2WasmMachine.call_1686(memory, instance, args); + case 1687: + return Wat2WasmMachine.call_1687(memory, instance, args); + case 1688: + return Wat2WasmMachine.call_1688(memory, instance, args); + case 1689: + return Wat2WasmMachine.call_1689(memory, instance, args); + case 1690: + return Wat2WasmMachine.call_1690(memory, instance, args); + case 1691: + return Wat2WasmMachine.call_1691(memory, instance, args); + case 1692: + return Wat2WasmMachine.call_1692(memory, instance, args); + case 1693: + return Wat2WasmMachine.call_1693(memory, instance, args); + case 1694: + return Wat2WasmMachine.call_1694(memory, instance, args); + case 1695: + return Wat2WasmMachine.call_1695(memory, instance, args); + case 1696: + return Wat2WasmMachine.call_1696(memory, instance, args); + case 1697: + return Wat2WasmMachine.call_1697(memory, instance, args); + case 1698: + return Wat2WasmMachine.call_1698(memory, instance, args); + case 1699: + return Wat2WasmMachine.call_1699(memory, instance, args); + case 1700: + return Wat2WasmMachine.call_1700(memory, instance, args); + case 1701: + return Wat2WasmMachine.call_1701(memory, instance, args); + case 1702: + return Wat2WasmMachine.call_1702(memory, instance, args); + case 1703: + return Wat2WasmMachine.call_1703(memory, instance, args); + case 1704: + return Wat2WasmMachine.call_1704(memory, instance, args); + case 1705: + return Wat2WasmMachine.call_1705(memory, instance, args); + case 1706: + return Wat2WasmMachine.call_1706(memory, instance, args); + case 1707: + return Wat2WasmMachine.call_1707(memory, instance, args); + case 1708: + return Wat2WasmMachine.call_1708(memory, instance, args); + case 1709: + return Wat2WasmMachine.call_1709(memory, instance, args); + case 1710: + return Wat2WasmMachine.call_1710(memory, instance, args); + case 1711: + return Wat2WasmMachine.call_1711(memory, instance, args); + case 1712: + return Wat2WasmMachine.call_1712(memory, instance, args); + case 1713: + return Wat2WasmMachine.call_1713(memory, instance, args); + case 1714: + return Wat2WasmMachine.call_1714(memory, instance, args); + case 1715: + return Wat2WasmMachine.call_1715(memory, instance, args); + case 1716: + return Wat2WasmMachine.call_1716(memory, instance, args); + case 1717: + return Wat2WasmMachine.call_1717(memory, instance, args); + case 1718: + return Wat2WasmMachine.call_1718(memory, instance, args); + case 1719: + return Wat2WasmMachine.call_1719(memory, instance, args); + case 1720: + return Wat2WasmMachine.call_1720(memory, instance, args); + case 1721: + return Wat2WasmMachine.call_1721(memory, instance, args); + case 1722: + return Wat2WasmMachine.call_1722(memory, instance, args); + case 1723: + return Wat2WasmMachine.call_1723(memory, instance, args); + case 1724: + return Wat2WasmMachine.call_1724(memory, instance, args); + case 1725: + return Wat2WasmMachine.call_1725(memory, instance, args); + case 1726: + return Wat2WasmMachine.call_1726(memory, instance, args); + case 1727: + return Wat2WasmMachine.call_1727(memory, instance, args); + case 1728: + return Wat2WasmMachine.call_1728(memory, instance, args); + case 1729: + return Wat2WasmMachine.call_1729(memory, instance, args); + case 1730: + return Wat2WasmMachine.call_1730(memory, instance, args); + case 1731: + return Wat2WasmMachine.call_1731(memory, instance, args); + case 1732: + return Wat2WasmMachine.call_1732(memory, instance, args); + case 1733: + return Wat2WasmMachine.call_1733(memory, instance, args); + case 1734: + return Wat2WasmMachine.call_1734(memory, instance, args); + case 1735: + return Wat2WasmMachine.call_1735(memory, instance, args); + case 1736: + return Wat2WasmMachine.call_1736(memory, instance, args); + case 1737: + return Wat2WasmMachine.call_1737(memory, instance, args); + case 1738: + return Wat2WasmMachine.call_1738(memory, instance, args); + case 1739: + return Wat2WasmMachine.call_1739(memory, instance, args); + case 1740: + return Wat2WasmMachine.call_1740(memory, instance, args); + case 1741: + return Wat2WasmMachine.call_1741(memory, instance, args); + case 1742: + return Wat2WasmMachine.call_1742(memory, instance, args); + case 1743: + return Wat2WasmMachine.call_1743(memory, instance, args); + case 1744: + return Wat2WasmMachine.call_1744(memory, instance, args); + case 1745: + return Wat2WasmMachine.call_1745(memory, instance, args); + case 1746: + return Wat2WasmMachine.call_1746(memory, instance, args); + case 1747: + return Wat2WasmMachine.call_1747(memory, instance, args); + case 1748: + return Wat2WasmMachine.call_1748(memory, instance, args); + case 1749: + return Wat2WasmMachine.call_1749(memory, instance, args); + case 1750: + return Wat2WasmMachine.call_1750(memory, instance, args); + case 1751: + return Wat2WasmMachine.call_1751(memory, instance, args); + case 1752: + return Wat2WasmMachine.call_1752(memory, instance, args); + case 1753: + return Wat2WasmMachine.call_1753(memory, instance, args); + case 1754: + return Wat2WasmMachine.call_1754(memory, instance, args); + case 1755: + return Wat2WasmMachine.call_1755(memory, instance, args); + case 1756: + return Wat2WasmMachine.call_1756(memory, instance, args); + case 1757: + return Wat2WasmMachine.call_1757(memory, instance, args); + case 1758: + return Wat2WasmMachine.call_1758(memory, instance, args); + case 1759: + return Wat2WasmMachine.call_1759(memory, instance, args); + case 1760: + return Wat2WasmMachine.call_1760(memory, instance, args); + case 1761: + return Wat2WasmMachine.call_1761(memory, instance, args); + case 1762: + return Wat2WasmMachine.call_1762(memory, instance, args); + case 1763: + return Wat2WasmMachine.call_1763(memory, instance, args); + case 1764: + return Wat2WasmMachine.call_1764(memory, instance, args); + case 1765: + return Wat2WasmMachine.call_1765(memory, instance, args); + case 1766: + return Wat2WasmMachine.call_1766(memory, instance, args); + case 1767: + return Wat2WasmMachine.call_1767(memory, instance, args); + case 1768: + return Wat2WasmMachine.call_1768(memory, instance, args); + case 1769: + return Wat2WasmMachine.call_1769(memory, instance, args); + case 1770: + return Wat2WasmMachine.call_1770(memory, instance, args); + case 1771: + return Wat2WasmMachine.call_1771(memory, instance, args); + case 1772: + return Wat2WasmMachine.call_1772(memory, instance, args); + case 1773: + return Wat2WasmMachine.call_1773(memory, instance, args); + case 1774: + return Wat2WasmMachine.call_1774(memory, instance, args); + case 1775: + return Wat2WasmMachine.call_1775(memory, instance, args); + case 1776: + return Wat2WasmMachine.call_1776(memory, instance, args); + case 1777: + return Wat2WasmMachine.call_1777(memory, instance, args); + case 1778: + return Wat2WasmMachine.call_1778(memory, instance, args); + case 1779: + return Wat2WasmMachine.call_1779(memory, instance, args); + case 1780: + return Wat2WasmMachine.call_1780(memory, instance, args); + case 1781: + return Wat2WasmMachine.call_1781(memory, instance, args); + case 1782: + return Wat2WasmMachine.call_1782(memory, instance, args); + case 1783: + return Wat2WasmMachine.call_1783(memory, instance, args); + case 1784: + return Wat2WasmMachine.call_1784(memory, instance, args); + case 1785: + return Wat2WasmMachine.call_1785(memory, instance, args); + case 1786: + return Wat2WasmMachine.call_1786(memory, instance, args); + case 1787: + return Wat2WasmMachine.call_1787(memory, instance, args); + case 1788: + return Wat2WasmMachine.call_1788(memory, instance, args); + case 1789: + return Wat2WasmMachine.call_1789(memory, instance, args); + case 1790: + return Wat2WasmMachine.call_1790(memory, instance, args); + case 1791: + return Wat2WasmMachine.call_1791(memory, instance, args); + case 1792: + return Wat2WasmMachine.call_1792(memory, instance, args); + case 1793: + return Wat2WasmMachine.call_1793(memory, instance, args); + case 1794: + return Wat2WasmMachine.call_1794(memory, instance, args); + case 1795: + return Wat2WasmMachine.call_1795(memory, instance, args); + case 1796: + return Wat2WasmMachine.call_1796(memory, instance, args); + case 1797: + return Wat2WasmMachine.call_1797(memory, instance, args); + case 1798: + return Wat2WasmMachine.call_1798(memory, instance, args); + case 1799: + return Wat2WasmMachine.call_1799(memory, instance, args); + case 1800: + return Wat2WasmMachine.call_1800(memory, instance, args); + case 1801: + return Wat2WasmMachine.call_1801(memory, instance, args); + case 1802: + return Wat2WasmMachine.call_1802(memory, instance, args); + case 1803: + return Wat2WasmMachine.call_1803(memory, instance, args); + case 1804: + return Wat2WasmMachine.call_1804(memory, instance, args); + case 1805: + return Wat2WasmMachine.call_1805(memory, instance, args); + case 1806: + return Wat2WasmMachine.call_1806(memory, instance, args); + case 1807: + return Wat2WasmMachine.call_1807(memory, instance, args); + case 1808: + return Wat2WasmMachine.call_1808(memory, instance, args); + case 1809: + return Wat2WasmMachine.call_1809(memory, instance, args); + case 1810: + return Wat2WasmMachine.call_1810(memory, instance, args); + case 1811: + return Wat2WasmMachine.call_1811(memory, instance, args); + case 1812: + return Wat2WasmMachine.call_1812(memory, instance, args); + case 1813: + return Wat2WasmMachine.call_1813(memory, instance, args); + case 1814: + return Wat2WasmMachine.call_1814(memory, instance, args); + case 1815: + return Wat2WasmMachine.call_1815(memory, instance, args); + case 1816: + return Wat2WasmMachine.call_1816(memory, instance, args); + case 1817: + return Wat2WasmMachine.call_1817(memory, instance, args); + case 1818: + return Wat2WasmMachine.call_1818(memory, instance, args); + case 1819: + return Wat2WasmMachine.call_1819(memory, instance, args); + case 1820: + return Wat2WasmMachine.call_1820(memory, instance, args); + case 1821: + return Wat2WasmMachine.call_1821(memory, instance, args); + case 1822: + return Wat2WasmMachine.call_1822(memory, instance, args); + case 1823: + return Wat2WasmMachine.call_1823(memory, instance, args); + case 1824: + return Wat2WasmMachine.call_1824(memory, instance, args); + case 1825: + return Wat2WasmMachine.call_1825(memory, instance, args); + case 1826: + return Wat2WasmMachine.call_1826(memory, instance, args); + case 1827: + return Wat2WasmMachine.call_1827(memory, instance, args); + case 1828: + return Wat2WasmMachine.call_1828(memory, instance, args); + case 1829: + return Wat2WasmMachine.call_1829(memory, instance, args); + case 1830: + return Wat2WasmMachine.call_1830(memory, instance, args); + case 1831: + return Wat2WasmMachine.call_1831(memory, instance, args); + case 1832: + return Wat2WasmMachine.call_1832(memory, instance, args); + case 1833: + return Wat2WasmMachine.call_1833(memory, instance, args); + case 1834: + return Wat2WasmMachine.call_1834(memory, instance, args); + case 1835: + return Wat2WasmMachine.call_1835(memory, instance, args); + case 1836: + return Wat2WasmMachine.call_1836(memory, instance, args); + case 1837: + return Wat2WasmMachine.call_1837(memory, instance, args); + case 1838: + return Wat2WasmMachine.call_1838(memory, instance, args); + case 1839: + return Wat2WasmMachine.call_1839(memory, instance, args); + case 1840: + return Wat2WasmMachine.call_1840(memory, instance, args); + case 1841: + return Wat2WasmMachine.call_1841(memory, instance, args); + case 1842: + return Wat2WasmMachine.call_1842(memory, instance, args); + case 1843: + return Wat2WasmMachine.call_1843(memory, instance, args); + case 1844: + return Wat2WasmMachine.call_1844(memory, instance, args); + case 1845: + return Wat2WasmMachine.call_1845(memory, instance, args); + case 1846: + return Wat2WasmMachine.call_1846(memory, instance, args); + case 1847: + return Wat2WasmMachine.call_1847(memory, instance, args); + case 1848: + return Wat2WasmMachine.call_1848(memory, instance, args); + case 1849: + return Wat2WasmMachine.call_1849(memory, instance, args); + case 1850: + return Wat2WasmMachine.call_1850(memory, instance, args); + case 1851: + return Wat2WasmMachine.call_1851(memory, instance, args); + case 1852: + return Wat2WasmMachine.call_1852(memory, instance, args); + case 1853: + return Wat2WasmMachine.call_1853(memory, instance, args); + case 1854: + return Wat2WasmMachine.call_1854(memory, instance, args); + case 1855: + return Wat2WasmMachine.call_1855(memory, instance, args); + case 1856: + return Wat2WasmMachine.call_1856(memory, instance, args); + case 1857: + return Wat2WasmMachine.call_1857(memory, instance, args); + case 1858: + return Wat2WasmMachine.call_1858(memory, instance, args); + case 1859: + return Wat2WasmMachine.call_1859(memory, instance, args); + case 1860: + return Wat2WasmMachine.call_1860(memory, instance, args); + case 1861: + return Wat2WasmMachine.call_1861(memory, instance, args); + case 1862: + return Wat2WasmMachine.call_1862(memory, instance, args); + case 1863: + return Wat2WasmMachine.call_1863(memory, instance, args); + case 1864: + return Wat2WasmMachine.call_1864(memory, instance, args); + case 1865: + return Wat2WasmMachine.call_1865(memory, instance, args); + case 1866: + return Wat2WasmMachine.call_1866(memory, instance, args); + case 1867: + return Wat2WasmMachine.call_1867(memory, instance, args); + case 1868: + return Wat2WasmMachine.call_1868(memory, instance, args); + case 1869: + return Wat2WasmMachine.call_1869(memory, instance, args); + case 1870: + return Wat2WasmMachine.call_1870(memory, instance, args); + case 1871: + return Wat2WasmMachine.call_1871(memory, instance, args); + case 1872: + return Wat2WasmMachine.call_1872(memory, instance, args); + case 1873: + return Wat2WasmMachine.call_1873(memory, instance, args); + case 1874: + return Wat2WasmMachine.call_1874(memory, instance, args); + case 1875: + return Wat2WasmMachine.call_1875(memory, instance, args); + case 1876: + return Wat2WasmMachine.call_1876(memory, instance, args); + case 1877: + return Wat2WasmMachine.call_1877(memory, instance, args); + case 1878: + return Wat2WasmMachine.call_1878(memory, instance, args); + case 1879: + return Wat2WasmMachine.call_1879(memory, instance, args); + case 1880: + return Wat2WasmMachine.call_1880(memory, instance, args); + case 1881: + return Wat2WasmMachine.call_1881(memory, instance, args); + case 1882: + return Wat2WasmMachine.call_1882(memory, instance, args); + case 1883: + return Wat2WasmMachine.call_1883(memory, instance, args); + case 1884: + return Wat2WasmMachine.call_1884(memory, instance, args); + case 1885: + return Wat2WasmMachine.call_1885(memory, instance, args); + case 1886: + return Wat2WasmMachine.call_1886(memory, instance, args); + case 1887: + return Wat2WasmMachine.call_1887(memory, instance, args); + case 1888: + return Wat2WasmMachine.call_1888(memory, instance, args); + case 1889: + return Wat2WasmMachine.call_1889(memory, instance, args); + case 1890: + return Wat2WasmMachine.call_1890(memory, instance, args); + case 1891: + return Wat2WasmMachine.call_1891(memory, instance, args); + case 1892: + return Wat2WasmMachine.call_1892(memory, instance, args); + case 1893: + return Wat2WasmMachine.call_1893(memory, instance, args); + case 1894: + return Wat2WasmMachine.call_1894(memory, instance, args); + case 1895: + return Wat2WasmMachine.call_1895(memory, instance, args); + case 1896: + return Wat2WasmMachine.call_1896(memory, instance, args); + case 1897: + return Wat2WasmMachine.call_1897(memory, instance, args); + case 1898: + return Wat2WasmMachine.call_1898(memory, instance, args); + case 1899: + return Wat2WasmMachine.call_1899(memory, instance, args); + default: + throw new com.dylibso.chicory.wasm.InvalidException(String.format("unknown function %d", funcId)); + } + } catch (StackOverflowError e) { + throw new com.dylibso.chicory.wasm.ChicoryException("call stack exhausted", e); + } + } + + private static int func_41__h0(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[24] = memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 21) & 0xFF)) != 0) { + break _hb; + } + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 536, (long) 0L); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 544, (int) 0); + long[] callArgs_227 = new long[2]; + callArgs_227[1] = ((long) 16984); + callArgs_227[0] = ((long) iL[0]); + instance.getMachine().call(52, callArgs_227); + label_237: { + iL[25] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[24] = ((int) memory.read((int) iL[25] < 0 ? iL[25] : iL[25] + 31) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[24]), 0) != 0 ? memory.readInt((int) (iL[25] + 24) < 0 ? (iL[25] + 24) : (iL[25] + 24) + 0) : iL[24])) != 0) { + break label_237; + } + long[] callArgs_228 = new long[3]; + callArgs_228[2] = ((long) 16291); + callArgs_228[1] = ((long) 0); + callArgs_228[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_228); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[37] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[38] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + long[] callArgs_229 = new long[5]; + callArgs_229[4] = ((long) 0); + callArgs_229[3] = ((long) 30166); + callArgs_229[2] = ((long) (iL[37] != 0 ? 1 : 5)); + callArgs_229[1] = ((long) (iL[23] + 560)); + callArgs_229[0] = ((long) iL[24]); + instance.getMachine().call(224, callArgs_229); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[38]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4)); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[36] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 20); + iL[38] = (int) (byte) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 31); + iL[30] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[38], 0); + iL[38] = (iL[30] != 0 ? memory.readInt((int) (iL[24] + 24) < 0 ? (iL[24] + 24) : (iL[24] + 24) + 0) : (iL[38] & 255)); + iL[25] = (iL[38] + -1); + iL[25] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[25], iL[38]) != 0 ? 0 : iL[25]); + long[] callArgs_230 = new long[3]; + callArgs_230[2] = ((long) 14225); + callArgs_230[1] = ((long) iL[25]); + callArgs_230[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_230); + long[] callArgs_231 = new long[5]; + callArgs_231[4] = ((long) 1); + callArgs_231[3] = ((long) 16938); + callArgs_231[2] = ((long) iL[25]); + callArgs_231[1] = ((long) ((iL[30] != 0 ? iL[36] : (iL[24] + 20)) + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[38]))); + callArgs_231[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_231); + long[] callArgs_232 = new long[4]; + callArgs_232[3] = ((long) 14990); + callArgs_232[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_232[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_232[0] = ((long) iL[0]); + long[] callResult_232 = instance.getMachine().call(48, callArgs_232); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + iL[25] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_238: { + iL[24] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 76); + iL[36] = memory.readInt((int) (iL[25] + 80) < 0 ? (iL[25] + 80) : (iL[25] + 80) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_238; + } + iL[37] = 0; + label_239: while (true) { + iL[38] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + iL[12] = iL[38]; + iL[38] = ((int) memory.read((int) iL[38] < 0 ? iL[38] : iL[38] + 11) & 0xFF); + iL[37] = (iL[37] + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[38]), 0) != 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 4) : iL[38]))); + iL[24] = (iL[24] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_239; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[37]) != 0) { + break label_238; + } + long[] callArgs_233 = new long[3]; + callArgs_233[2] = ((long) 15842); + callArgs_233[1] = ((long) 1); + callArgs_233[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_233); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[38] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[36] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + long[] callArgs_234 = new long[5]; + callArgs_234[4] = ((long) 0); + callArgs_234[3] = ((long) 30166); + callArgs_234[2] = ((long) (iL[38] != 0 ? 1 : 5)); + callArgs_234[1] = ((long) (iL[23] + 560)); + callArgs_234[0] = ((long) iL[24]); + instance.getMachine().call(224, callArgs_234); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[36]); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4)); + long[] callArgs_235 = new long[3]; + callArgs_235[2] = ((long) 8553); + callArgs_235[1] = ((long) iL[37]); + callArgs_235[0] = ((long) iL[24]); + instance.getMachine().call(169, callArgs_235); + label_240: { + iL[31] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 80); + iL[36] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[31]) != 0) { + break label_240; + } + iL[38] = 0; + iL[37] = 0; + label_241: while (true) { + label_242: { + iL[24] = memory.readInt((int) (iL[36] + iL[38]) < 0 ? (iL[36] + iL[38]) : (iL[36] + iL[38]) + 0); + iL[30] = ((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 11) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[30]), 0) != 0 ? memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4) : iL[30])) != 0) { + break label_242; + } + long[] callArgs_236 = new long[3]; + callArgs_236[2] = ((long) 1617); + callArgs_236[1] = ((long) iL[37]); + callArgs_236[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_236); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 160, (int) iL[37]); + long[] callArgs_237 = new long[4]; + callArgs_237[3] = ((long) (iL[23] + 160)); + callArgs_237[2] = ((long) 17586); + callArgs_237[1] = ((long) 100); + callArgs_237[0] = ((long) (iL[23] + 560)); + long[] callResult_237 = instance.getMachine().call(1865, callArgs_237); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[36] = ((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 11) & 0xFF); + iL[27] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[36]), 0); + iL[36] = (iL[27] != 0 ? memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4) : iL[36]); + iL[26] = (iL[36] + -1); + iL[26] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[26], iL[36]) != 0 ? 0 : iL[26]); + long[] callArgs_238 = new long[3]; + callArgs_238[2] = ((long) 14225); + callArgs_238[1] = ((long) iL[26]); + callArgs_238[0] = ((long) iL[31]); + instance.getMachine().call(169, callArgs_238); + long[] callArgs_239 = new long[5]; + callArgs_239[4] = ((long) 1); + callArgs_239[3] = ((long) (iL[23] + 560)); + callArgs_239[2] = ((long) iL[26]); + callArgs_239[1] = ((long) ((iL[27] != 0 ? iL[30] : iL[24]) + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[36]))); + callArgs_239[0] = ((long) iL[31]); + instance.getMachine().call(224, callArgs_239); + iL[36] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 76); + iL[31] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 80); + } + iL[38] = (iL[38] + 4); + iL[37] = (iL[37] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[37], ((iL[31] - iL[36]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_241; + } + break; + } + } + long[] callArgs_240 = new long[4]; + callArgs_240[3] = ((long) 14990); + callArgs_240[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_240[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_240[0] = ((long) iL[0]); + long[] callResult_240 = instance.getMachine().call(48, callArgs_240); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + } + long[] callArgs_241 = new long[3]; + callArgs_241[2] = ((long) 16275); + callArgs_241[1] = ((long) 2); + callArgs_241[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_241); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[37] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[38] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + long[] callArgs_242 = new long[5]; + callArgs_242[4] = ((long) 0); + callArgs_242[3] = ((long) 30166); + callArgs_242[2] = ((long) (iL[37] != 0 ? 1 : 5)); + callArgs_242[1] = ((long) (iL[23] + 560)); + callArgs_242[0] = ((long) iL[24]); + instance.getMachine().call(224, callArgs_242); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[38]); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4)); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + long[] callArgs_243 = new long[3]; + callArgs_243[2] = ((long) 7922); + callArgs_243[1] = ((long) ((memory.readInt((int) (iL[37] + 80) < 0 ? (iL[37] + 80) : (iL[37] + 80) + 0) - memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 76)) >> 2)); + callArgs_243[0] = ((long) iL[24]); + instance.getMachine().call(169, callArgs_243); + label_243: { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[11] = iL[24]; + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[24], memory.readInt((int) (iL[11] + 80) < 0 ? (iL[11] + 80) : (iL[11] + 80) + 0)) != 0) { + break label_243; + } + iL[28] = 0; + label_244: while (true) { + iL[24] = memory.readInt((int) (iL[24] + (iL[28] << 2)) < 0 ? (iL[24] + (iL[28] << 2)) : (iL[24] + (iL[28] << 2)) + 0); + long[] callArgs_244 = new long[1]; + callArgs_244[0] = ((long) (iL[24] + 116)); + long[] callResult_244 = instance.getMachine().call(130, callArgs_244); + iL[26] = (((memory.readInt((int) (iL[24] + 56) < 0 ? (iL[24] + 56) : (iL[24] + 56) + 0) - memory.readInt((int) (iL[24] + 52) < 0 ? (iL[24] + 52) : (iL[24] + 52) + 0)) >> 3) + ((int) callResult_244[0])); + long[] callArgs_245 = new long[3]; + callArgs_245[2] = ((long) (iL[23] + 536)); + callArgs_245[1] = ((long) (iL[24] + 128)); + callArgs_245[0] = ((long) iL[26]); + instance.getMachine().call(152, callArgs_245); + label_245: { + label_246: { + iL[24] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 536); + iL[30] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 540); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[24]) != 0) { + break label_246; + } + iL[37] = 0; + break label_245; + } + iL[37] = 0; + label_247: while (true) { + label_248: { + label_249: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) (iL[24] + 11) < 0 ? (iL[24] + 11) : (iL[24] + 11) + 0), 0) != 0) { + break label_249; + } + memory.writeI32((int) ((iL[23] + 560) + 8) < 0 ? ((iL[23] + 560) + 8) : ((iL[23] + 560) + 8) + 0, (int) memory.readInt((int) (iL[24] + 8) < 0 ? (iL[24] + 8) : (iL[24] + 8) + 0)); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (long) memory.readLong((int) iL[24] < 0 ? iL[24] : iL[24] + 0)); + break label_248; + } + long[] callArgs_246 = new long[3]; + callArgs_246[2] = ((long) memory.readInt((int) (iL[24] + 4) < 0 ? (iL[24] + 4) : (iL[24] + 4) + 0)); + callArgs_246[1] = ((long) memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0)); + callArgs_246[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(1647, callArgs_246); + } + iL[38] = ((int) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571) & 0xFF); + iL[10] = iL[38]; + iL[38] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[38]); + iL[36] = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[38], 0) != 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 564) : iL[10])); + label_250: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[38], -1) != 0) { + break label_250; + } + long[] callArgs_247 = new long[1]; + callArgs_247[0] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560)); + instance.getMachine().call(1777, callArgs_247); + } + iL[37] = (iL[37] + iL[36]); + iL[24] = (iL[24] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_247; + } + break; + } + } + long[] callArgs_248 = new long[3]; + callArgs_248[2] = ((long) 1564); + callArgs_248[1] = ((long) iL[28]); + callArgs_248[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_248); + long[] callArgs_249 = new long[3]; + callArgs_249[2] = ((long) 8150); + callArgs_249[1] = ((long) iL[37]); + callArgs_249[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_249); + label_251: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[26]) != 0) { + break label_251; + } + iL[38] = 0; + iL[24] = 0; + label_252: while (true) { + label_253: { + iL[37] = (memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 536) + iL[38]); + iL[30] = (iL[37] + 4); + iL[25] = (iL[37] + 11); + iL[36] = ((int) memory.read((int) iL[25] < 0 ? iL[25] : iL[25] + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[36]), 0) != 0 ? memory.readInt((int) iL[30] < 0 ? iL[30] : iL[30] + 0) : iL[36])) != 0) { + break label_253; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 144, (int) iL[24]); + long[] callArgs_250 = new long[4]; + callArgs_250[3] = ((long) (iL[23] + 144)); + callArgs_250[2] = ((long) 17600); + callArgs_250[1] = ((long) 100); + callArgs_250[0] = ((long) (iL[23] + 384)); + long[] callResult_250 = instance.getMachine().call(1865, callArgs_250); + long[] callArgs_251 = new long[3]; + callArgs_251[2] = ((long) 1695); + callArgs_251[1] = ((long) iL[24]); + callArgs_251[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_251); + iL[31] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[27] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[36] = ((int) memory.read((int) iL[25] < 0 ? iL[25] : iL[25] + 0) & 0xFF); + iL[9] = iL[30]; + iL[30] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[36]), 0); + iL[36] = (iL[30] != 0 ? memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) : iL[36]); + iL[25] = (iL[36] + -1); + iL[25] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[25], iL[36]) != 0 ? 0 : iL[25]); + long[] callArgs_252 = new long[3]; + callArgs_252[2] = ((long) 14225); + callArgs_252[1] = ((long) iL[25]); + callArgs_252[0] = ((long) iL[27]); + instance.getMachine().call(169, callArgs_252); + long[] callArgs_253 = new long[5]; + callArgs_253[4] = ((long) 1); + callArgs_253[3] = ((long) (iL[23] + 384)); + callArgs_253[2] = ((long) iL[25]); + callArgs_253[1] = ((long) ((iL[30] != 0 ? iL[31] : iL[37]) + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[36]))); + callArgs_253[0] = ((long) iL[27]); + instance.getMachine().call(224, callArgs_253); + } + iL[38] = (iL[38] + 12); + iL[24] = (iL[24] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[24], iL[26]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_252; + } + break; + } + } + iL[28] = (iL[28] + 1); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[8] = iL[24]; + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[28], ((memory.readInt((int) (iL[8] + 80) < 0 ? (iL[8] + 80) : (iL[8] + 80) + 0) - iL[24]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_244; + } + break; + } + } + long[] callArgs_254 = new long[4]; + callArgs_254[3] = ((long) 14990); + callArgs_254[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_254[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_254[0] = ((long) iL[0]); + long[] callResult_254 = instance.getMachine().call(48, callArgs_254); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + label_254: { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 124); + iL[30] = memory.readInt((int) (iL[24] + 128) < 0 ? (iL[24] + 128) : (iL[24] + 128) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[37]) != 0) { + break label_254; + } + iL[38] = 0; + label_255: while (true) { + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[7] = iL[36]; + iL[36] = ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 35) & 0xFF); + iL[38] = (iL[38] + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[36]), 0) != 0 ? memory.readInt((int) (iL[7] + 28) < 0 ? (iL[7] + 28) : (iL[7] + 28) + 0) : iL[36]))); + iL[37] = (iL[37] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_255; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_254; + } + long[] callArgs_255 = new long[3]; + callArgs_255[2] = ((long) 15842); + callArgs_255[1] = ((long) 4); + callArgs_255[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_255); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[36] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[30] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + long[] callArgs_256 = new long[5]; + callArgs_256[4] = ((long) 0); + callArgs_256[3] = ((long) 30166); + callArgs_256[2] = ((long) (iL[36] != 0 ? 1 : 5)); + callArgs_256[1] = ((long) (iL[23] + 560)); + callArgs_256[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_256); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[30]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4)); + long[] callArgs_257 = new long[3]; + callArgs_257[2] = ((long) 8553); + callArgs_257[1] = ((long) iL[38]); + callArgs_257[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_257); + label_256: { + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 128); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[31]) != 0) { + break label_256; + } + iL[36] = 0; + iL[38] = 0; + label_257: while (true) { + label_258: { + iL[37] = memory.readInt((int) (iL[30] + iL[36]) < 0 ? (iL[30] + iL[36]) : (iL[30] + iL[36]) + 0); + iL[25] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 35) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[25]), 0) != 0 ? memory.readInt((int) (iL[37] + 28) < 0 ? (iL[37] + 28) : (iL[37] + 28) + 0) : iL[25])) != 0) { + break label_258; + } + long[] callArgs_258 = new long[3]; + callArgs_258[2] = ((long) 1617); + callArgs_258[1] = ((long) iL[38]); + callArgs_258[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_258); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 128, (int) iL[38]); + long[] callArgs_259 = new long[4]; + callArgs_259[3] = ((long) (iL[23] + 128)); + callArgs_259[2] = ((long) 17586); + callArgs_259[1] = ((long) 100); + callArgs_259[0] = ((long) (iL[23] + 560)); + long[] callResult_259 = instance.getMachine().call(1865, callArgs_259); + iL[25] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 24); + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 35) & 0xFF); + iL[27] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[30]), 0); + iL[30] = (iL[27] != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 28) : iL[30]); + iL[26] = (iL[30] + -1); + iL[26] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[26], iL[30]) != 0 ? 0 : iL[26]); + long[] callArgs_260 = new long[3]; + callArgs_260[2] = ((long) 14225); + callArgs_260[1] = ((long) iL[26]); + callArgs_260[0] = ((long) iL[31]); + instance.getMachine().call(169, callArgs_260); + long[] callArgs_261 = new long[5]; + callArgs_261[4] = ((long) 1); + callArgs_261[3] = ((long) (iL[23] + 560)); + callArgs_261[2] = ((long) iL[26]); + callArgs_261[1] = ((long) ((iL[27] != 0 ? iL[25] : (iL[37] + 24)) + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[30]))); + callArgs_261[0] = ((long) iL[31]); + instance.getMachine().call(224, callArgs_261); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 124); + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 128); + } + iL[36] = (iL[36] + 4); + iL[38] = (iL[38] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], ((iL[31] - iL[30]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_257; + } + break; + } + } + long[] callArgs_262 = new long[4]; + callArgs_262[3] = ((long) 14990); + callArgs_262[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_262[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_262[0] = ((long) iL[0]); + long[] callResult_262 = instance.getMachine().call(48, callArgs_262); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_259: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 136); + iL[30] = memory.readInt((int) (iL[24] + 140) < 0 ? (iL[24] + 140) : (iL[24] + 140) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[37]) != 0) { + break label_259; + } + iL[38] = 0; + label_260: while (true) { + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[6] = iL[36]; + iL[36] = ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 11) & 0xFF); + iL[38] = (iL[38] + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[36]), 0) != 0 ? memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4) : iL[36]))); + iL[37] = (iL[37] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_260; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_259; + } + long[] callArgs_263 = new long[3]; + callArgs_263[2] = ((long) 15842); + callArgs_263[1] = ((long) 5); + callArgs_263[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_263); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[36] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[30] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + long[] callArgs_264 = new long[5]; + callArgs_264[4] = ((long) 0); + callArgs_264[3] = ((long) 30166); + callArgs_264[2] = ((long) (iL[36] != 0 ? 1 : 5)); + callArgs_264[1] = ((long) (iL[23] + 560)); + callArgs_264[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_264); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[30]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4)); + long[] callArgs_265 = new long[3]; + callArgs_265[2] = ((long) 8553); + callArgs_265[1] = ((long) iL[38]); + callArgs_265[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_265); + label_261: { + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 140); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 136); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[31]) != 0) { + break label_261; + } + iL[36] = 0; + iL[38] = 0; + label_262: while (true) { + label_263: { + iL[37] = memory.readInt((int) (iL[30] + iL[36]) < 0 ? (iL[30] + iL[36]) : (iL[30] + iL[36]) + 0); + iL[25] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 11) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[25]), 0) != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4) : iL[25])) != 0) { + break label_263; + } + long[] callArgs_266 = new long[3]; + callArgs_266[2] = ((long) 1617); + callArgs_266[1] = ((long) iL[38]); + callArgs_266[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_266); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 112, (int) iL[38]); + long[] callArgs_267 = new long[4]; + callArgs_267[3] = ((long) (iL[23] + 112)); + callArgs_267[2] = ((long) 17586); + callArgs_267[1] = ((long) 100); + callArgs_267[0] = ((long) (iL[23] + 560)); + long[] callResult_267 = instance.getMachine().call(1865, callArgs_267); + iL[25] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 11) & 0xFF); + iL[27] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[30]), 0); + iL[30] = (iL[27] != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4) : iL[30]); + iL[26] = (iL[30] + -1); + iL[26] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[26], iL[30]) != 0 ? 0 : iL[26]); + long[] callArgs_268 = new long[3]; + callArgs_268[2] = ((long) 14225); + callArgs_268[1] = ((long) iL[26]); + callArgs_268[0] = ((long) iL[31]); + instance.getMachine().call(169, callArgs_268); + long[] callArgs_269 = new long[5]; + callArgs_269[4] = ((long) 1); + callArgs_269[3] = ((long) (iL[23] + 560)); + callArgs_269[2] = ((long) iL[26]); + callArgs_269[1] = ((long) ((iL[27] != 0 ? iL[25] : iL[37]) + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[30]))); + callArgs_269[0] = ((long) iL[31]); + instance.getMachine().call(224, callArgs_269); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 136); + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 140); + } + iL[36] = (iL[36] + 4); + iL[38] = (iL[38] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], ((iL[31] - iL[30]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_262; + } + break; + } + } + long[] callArgs_270 = new long[4]; + callArgs_270[3] = ((long) 14990); + callArgs_270[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_270[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_270[0] = ((long) iL[0]); + long[] callResult_270 = instance.getMachine().call(48, callArgs_270); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_264: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 160); + iL[30] = memory.readInt((int) (iL[24] + 164) < 0 ? (iL[24] + 164) : (iL[24] + 164) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[37]) != 0) { + break label_264; + } + iL[38] = 0; + label_265: while (true) { + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[5] = iL[36]; + iL[36] = ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 11) & 0xFF); + iL[38] = (iL[38] + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[36]), 0) != 0 ? memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 4) : iL[36]))); + iL[37] = (iL[37] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_265; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_264; + } + long[] callArgs_271 = new long[3]; + callArgs_271[2] = ((long) 15842); + callArgs_271[1] = ((long) 6); + callArgs_271[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_271); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[36] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[30] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + long[] callArgs_272 = new long[5]; + callArgs_272[4] = ((long) 0); + callArgs_272[3] = ((long) 30166); + callArgs_272[2] = ((long) (iL[36] != 0 ? 1 : 5)); + callArgs_272[1] = ((long) (iL[23] + 560)); + callArgs_272[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_272); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[30]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4)); + long[] callArgs_273 = new long[3]; + callArgs_273[2] = ((long) 8553); + callArgs_273[1] = ((long) iL[38]); + callArgs_273[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_273); + label_266: { + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 164); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 160); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[31]) != 0) { + break label_266; + } + iL[36] = 0; + iL[38] = 0; + label_267: while (true) { + label_268: { + iL[37] = memory.readInt((int) (iL[30] + iL[36]) < 0 ? (iL[30] + iL[36]) : (iL[30] + iL[36]) + 0); + iL[25] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 11) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[25]), 0) != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4) : iL[25])) != 0) { + break label_268; + } + long[] callArgs_274 = new long[3]; + callArgs_274[2] = ((long) 1617); + callArgs_274[1] = ((long) iL[38]); + callArgs_274[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_274); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 96, (int) iL[38]); + long[] callArgs_275 = new long[4]; + callArgs_275[3] = ((long) (iL[23] + 96)); + callArgs_275[2] = ((long) 17586); + callArgs_275[1] = ((long) 100); + callArgs_275[0] = ((long) (iL[23] + 560)); + long[] callResult_275 = instance.getMachine().call(1865, callArgs_275); + iL[25] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 11) & 0xFF); + iL[27] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[30]), 0); + iL[30] = (iL[27] != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4) : iL[30]); + iL[26] = (iL[30] + -1); + iL[26] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[26], iL[30]) != 0 ? 0 : iL[26]); + long[] callArgs_276 = new long[3]; + callArgs_276[2] = ((long) 14225); + callArgs_276[1] = ((long) iL[26]); + callArgs_276[0] = ((long) iL[31]); + instance.getMachine().call(169, callArgs_276); + long[] callArgs_277 = new long[5]; + callArgs_277[4] = ((long) 1); + callArgs_277[3] = ((long) (iL[23] + 560)); + callArgs_277[2] = ((long) iL[26]); + callArgs_277[1] = ((long) ((iL[27] != 0 ? iL[25] : iL[37]) + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[30]))); + callArgs_277[0] = ((long) iL[31]); + instance.getMachine().call(224, callArgs_277); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 160); + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 164); + } + iL[36] = (iL[36] + 4); + iL[38] = (iL[38] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], ((iL[31] - iL[30]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_267; + } + break; + } + } + long[] callArgs_278 = new long[4]; + callArgs_278[3] = ((long) 14990); + callArgs_278[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_278[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_278[0] = ((long) iL[0]); + long[] callResult_278 = instance.getMachine().call(48, callArgs_278); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_269: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 88); + iL[30] = memory.readInt((int) (iL[24] + 92) < 0 ? (iL[24] + 92) : (iL[24] + 92) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[37]) != 0) { + break label_269; + } + iL[38] = 0; + label_270: while (true) { + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[4] = iL[36]; + iL[36] = ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 11) & 0xFF); + iL[38] = (iL[38] + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[36]), 0) != 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 4) : iL[36]))); + iL[37] = (iL[37] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_270; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_269; + } + long[] callArgs_279 = new long[3]; + callArgs_279[2] = ((long) 15842); + callArgs_279[1] = ((long) 7); + callArgs_279[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_279); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[36] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[30] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + long[] callArgs_280 = new long[5]; + callArgs_280[4] = ((long) 0); + callArgs_280[3] = ((long) 30166); + callArgs_280[2] = ((long) (iL[36] != 0 ? 1 : 5)); + callArgs_280[1] = ((long) (iL[23] + 560)); + callArgs_280[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_280); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[30]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4)); + long[] callArgs_281 = new long[3]; + callArgs_281[2] = ((long) 8553); + callArgs_281[1] = ((long) iL[38]); + callArgs_281[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_281); + label_271: { + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 92); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[31]) != 0) { + break label_271; + } + iL[36] = 0; + iL[38] = 0; + label_272: while (true) { + label_273: { + iL[37] = memory.readInt((int) (iL[30] + iL[36]) < 0 ? (iL[30] + iL[36]) : (iL[30] + iL[36]) + 0); + iL[25] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 11) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[25]), 0) != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4) : iL[25])) != 0) { + break label_273; + } + long[] callArgs_282 = new long[3]; + callArgs_282[2] = ((long) 1617); + callArgs_282[1] = ((long) iL[38]); + callArgs_282[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_282); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 80, (int) iL[38]); + long[] callArgs_283 = new long[4]; + callArgs_283[3] = ((long) (iL[23] + 80)); + callArgs_283[2] = ((long) 17586); + callArgs_283[1] = ((long) 100); + callArgs_283[0] = ((long) (iL[23] + 560)); + long[] callResult_283 = instance.getMachine().call(1865, callArgs_283); + iL[25] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 11) & 0xFF); + iL[27] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[30]), 0); + iL[30] = (iL[27] != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4) : iL[30]); + iL[26] = (iL[30] + -1); + iL[26] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[26], iL[30]) != 0 ? 0 : iL[26]); + long[] callArgs_284 = new long[3]; + callArgs_284[2] = ((long) 14225); + callArgs_284[1] = ((long) iL[26]); + callArgs_284[0] = ((long) iL[31]); + instance.getMachine().call(169, callArgs_284); + long[] callArgs_285 = new long[5]; + callArgs_285[4] = ((long) 1); + callArgs_285[3] = ((long) (iL[23] + 560)); + callArgs_285[2] = ((long) iL[26]); + callArgs_285[1] = ((long) ((iL[27] != 0 ? iL[25] : iL[37]) + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[30]))); + callArgs_285[0] = ((long) iL[31]); + instance.getMachine().call(224, callArgs_285); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 88); + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 92); + } + iL[36] = (iL[36] + 4); + iL[38] = (iL[38] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], ((iL[31] - iL[30]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_272; + } + break; + } + } + long[] callArgs_286 = new long[4]; + callArgs_286[3] = ((long) 14990); + callArgs_286[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_286[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_286[0] = ((long) iL[0]); + long[] callResult_286 = instance.getMachine().call(48, callArgs_286); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_274: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 148); + iL[30] = memory.readInt((int) (iL[24] + 152) < 0 ? (iL[24] + 152) : (iL[24] + 152) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[37]) != 0) { + break label_274; + } + iL[38] = 0; + label_275: while (true) { + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[3] = iL[36]; + iL[36] = ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 15) & 0xFF); + iL[38] = (iL[38] + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[36]), 0) != 0 ? memory.readInt((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0) : iL[36]))); + iL[37] = (iL[37] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_275; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_274; + } + long[] callArgs_287 = new long[3]; + callArgs_287[2] = ((long) 15842); + callArgs_287[1] = ((long) 8); + callArgs_287[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_287); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[36] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[30] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + long[] callArgs_288 = new long[5]; + callArgs_288[4] = ((long) 0); + callArgs_288[3] = ((long) 30166); + callArgs_288[2] = ((long) (iL[36] != 0 ? 1 : 5)); + callArgs_288[1] = ((long) (iL[23] + 560)); + callArgs_288[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_288); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[30]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4)); + long[] callArgs_289 = new long[3]; + callArgs_289[2] = ((long) 8553); + callArgs_289[1] = ((long) iL[38]); + callArgs_289[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_289); + label_276: { + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 152); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 148); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[31]) != 0) { + break label_276; + } + iL[36] = 0; + iL[38] = 0; + label_277: while (true) { + label_278: { + iL[37] = memory.readInt((int) (iL[30] + iL[36]) < 0 ? (iL[30] + iL[36]) : (iL[30] + iL[36]) + 0); + iL[25] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 15) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[25]), 0) != 0 ? memory.readInt((int) (iL[37] + 8) < 0 ? (iL[37] + 8) : (iL[37] + 8) + 0) : iL[25])) != 0) { + break label_278; + } + long[] callArgs_290 = new long[3]; + callArgs_290[2] = ((long) 1617); + callArgs_290[1] = ((long) iL[38]); + callArgs_290[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_290); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 64, (int) iL[38]); + long[] callArgs_291 = new long[4]; + callArgs_291[3] = ((long) (iL[23] + 64)); + callArgs_291[2] = ((long) 17586); + callArgs_291[1] = ((long) 100); + callArgs_291[0] = ((long) (iL[23] + 560)); + long[] callResult_291 = instance.getMachine().call(1865, callArgs_291); + iL[25] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 15) & 0xFF); + iL[27] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[30]), 0); + iL[30] = (iL[27] != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 8) : iL[30]); + iL[26] = (iL[30] + -1); + iL[26] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[26], iL[30]) != 0 ? 0 : iL[26]); + long[] callArgs_292 = new long[3]; + callArgs_292[2] = ((long) 14225); + callArgs_292[1] = ((long) iL[26]); + callArgs_292[0] = ((long) iL[31]); + instance.getMachine().call(169, callArgs_292); + long[] callArgs_293 = new long[5]; + callArgs_293[4] = ((long) 1); + callArgs_293[3] = ((long) (iL[23] + 560)); + callArgs_293[2] = ((long) iL[26]); + callArgs_293[1] = ((long) ((iL[27] != 0 ? iL[25] : (iL[37] + 4)) + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[30]))); + callArgs_293[0] = ((long) iL[31]); + instance.getMachine().call(224, callArgs_293); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 148); + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 152); + } + iL[36] = (iL[36] + 4); + iL[38] = (iL[38] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], ((iL[31] - iL[30]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_277; + } + break; + } + } + long[] callArgs_294 = new long[4]; + callArgs_294[3] = ((long) 14990); + callArgs_294[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_294[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_294[0] = ((long) iL[0]); + long[] callResult_294 = instance.getMachine().call(48, callArgs_294); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_279: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 172); + iL[30] = memory.readInt((int) (iL[24] + 176) < 0 ? (iL[24] + 176) : (iL[24] + 176) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[37]) != 0) { + break label_279; + } + iL[38] = 0; + label_280: while (true) { + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[2] = iL[36]; + iL[36] = ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 15) & 0xFF); + iL[38] = (iL[38] + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[36]), 0) != 0 ? memory.readInt((int) (iL[2] + 8) < 0 ? (iL[2] + 8) : (iL[2] + 8) + 0) : iL[36]))); + iL[37] = (iL[37] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_280; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_279; + } + long[] callArgs_295 = new long[3]; + callArgs_295[2] = ((long) 15842); + callArgs_295[1] = ((long) 9); + callArgs_295[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_295); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[36] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[30] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + long[] callArgs_296 = new long[5]; + callArgs_296[4] = ((long) 0); + callArgs_296[3] = ((long) 30166); + callArgs_296[2] = ((long) (iL[36] != 0 ? 1 : 5)); + callArgs_296[1] = ((long) (iL[23] + 560)); + callArgs_296[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_296); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[30]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4)); + long[] callArgs_297 = new long[3]; + callArgs_297[2] = ((long) 8553); + callArgs_297[1] = ((long) iL[38]); + callArgs_297[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_297); + label_281: { + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 176); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 172); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[31]) != 0) { + break label_281; + } + iL[36] = 0; + iL[38] = 0; + label_282: while (true) { + label_283: { + iL[37] = memory.readInt((int) (iL[30] + iL[36]) < 0 ? (iL[30] + iL[36]) : (iL[30] + iL[36]) + 0); + iL[25] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 15) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[25]), 0) != 0 ? memory.readInt((int) (iL[37] + 8) < 0 ? (iL[37] + 8) : (iL[37] + 8) + 0) : iL[25])) != 0) { + break label_283; + } + long[] callArgs_298 = new long[3]; + callArgs_298[2] = ((long) 1617); + callArgs_298[1] = ((long) iL[38]); + callArgs_298[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_298); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 48, (int) iL[38]); + long[] callArgs_299 = new long[4]; + callArgs_299[3] = ((long) (iL[23] + 48)); + callArgs_299[2] = ((long) 17586); + callArgs_299[1] = ((long) 100); + callArgs_299[0] = ((long) (iL[23] + 560)); + long[] callResult_299 = instance.getMachine().call(1865, callArgs_299); + iL[25] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 15) & 0xFF); + iL[27] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[30]), 0); + iL[30] = (iL[27] != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 8) : iL[30]); + iL[26] = (iL[30] + -1); + iL[26] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[26], iL[30]) != 0 ? 0 : iL[26]); + long[] callArgs_300 = new long[3]; + callArgs_300[2] = ((long) 14225); + callArgs_300[1] = ((long) iL[26]); + callArgs_300[0] = ((long) iL[31]); + instance.getMachine().call(169, callArgs_300); + long[] callArgs_301 = new long[5]; + callArgs_301[4] = ((long) 1); + callArgs_301[3] = ((long) (iL[23] + 560)); + callArgs_301[2] = ((long) iL[26]); + callArgs_301[1] = ((long) ((iL[27] != 0 ? iL[25] : (iL[37] + 4)) + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[30]))); + callArgs_301[0] = ((long) iL[31]); + instance.getMachine().call(224, callArgs_301); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 172); + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 176); + } + iL[36] = (iL[36] + 4); + iL[38] = (iL[38] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], ((iL[31] - iL[30]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_282; + } + break; + } + } + long[] callArgs_302 = new long[4]; + callArgs_302[3] = ((long) 14990); + callArgs_302[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_302[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_302[0] = ((long) iL[0]); + long[] callResult_302 = instance.getMachine().call(48, callArgs_302); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + label_284: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 64); + iL[30] = memory.readInt((int) (iL[24] + 68) < 0 ? (iL[24] + 68) : (iL[24] + 68) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[37]) != 0) { + break label_284; + } + iL[38] = 0; + label_285: while (true) { + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[1] = iL[36]; + iL[36] = ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 11) & 0xFF); + iL[38] = (iL[38] + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[36]), 0) != 0 ? memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4) : iL[36]))); + iL[37] = (iL[37] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_285; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_284; + } + long[] callArgs_303 = new long[3]; + callArgs_303[2] = ((long) 15842); + callArgs_303[1] = ((long) 11); + callArgs_303[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_303); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[36] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[30] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + long[] callArgs_304 = new long[5]; + callArgs_304[4] = ((long) 0); + callArgs_304[3] = ((long) 30166); + callArgs_304[2] = ((long) (iL[36] != 0 ? 1 : 5)); + callArgs_304[1] = ((long) (iL[23] + 560)); + callArgs_304[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_304); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[30]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4)); + long[] callArgs_305 = new long[3]; + callArgs_305[2] = ((long) 8553); + callArgs_305[1] = ((long) iL[38]); + callArgs_305[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_305); + label_286: { + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 68); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[31]) != 0) { + break label_286; + } + iL[36] = 0; + iL[38] = 0; + label_287: while (true) { + label_288: { + iL[37] = memory.readInt((int) (iL[30] + iL[36]) < 0 ? (iL[30] + iL[36]) : (iL[30] + iL[36]) + 0); + iL[25] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 11) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[25]), 0) != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4) : iL[25])) != 0) { + break label_288; + } + long[] callArgs_306 = new long[3]; + callArgs_306[2] = ((long) 1617); + callArgs_306[1] = ((long) iL[38]); + callArgs_306[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_306); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 32, (int) iL[38]); + long[] callArgs_307 = new long[4]; + callArgs_307[3] = ((long) (iL[23] + 32)); + callArgs_307[2] = ((long) 17586); + callArgs_307[1] = ((long) 100); + callArgs_307[0] = ((long) (iL[23] + 560)); + long[] callResult_307 = instance.getMachine().call(1865, callArgs_307); + iL[25] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 11) & 0xFF); + iL[27] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[30]), 0); + iL[30] = (iL[27] != 0 ? memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4) : iL[30]); + iL[26] = (iL[30] + -1); + iL[26] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[26], iL[30]) != 0 ? 0 : iL[26]); + long[] callArgs_308 = new long[3]; + callArgs_308[2] = ((long) 14225); + callArgs_308[1] = ((long) iL[26]); + callArgs_308[0] = ((long) iL[31]); + instance.getMachine().call(169, callArgs_308); + long[] callArgs_309 = new long[5]; + callArgs_309[4] = ((long) 1); + callArgs_309[3] = ((long) (iL[23] + 560)); + callArgs_309[2] = ((long) iL[26]); + callArgs_309[1] = ((long) ((iL[27] != 0 ? iL[25] : iL[37]) + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[30]))); + callArgs_309[0] = ((long) iL[31]); + instance.getMachine().call(224, callArgs_309); + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 64); + iL[31] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 68); + } + iL[36] = (iL[36] + 4); + iL[38] = (iL[38] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], ((iL[31] - iL[30]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_287; + } + break; + } + } + long[] callArgs_310 = new long[4]; + callArgs_310[3] = ((long) 14990); + callArgs_310[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_310[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_310[0] = ((long) iL[0]); + long[] callResult_310 = instance.getMachine().call(48, callArgs_310); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + } + long[] callArgs_311 = new long[4]; + callArgs_311[3] = ((long) 15012); + callArgs_311[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_311[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_311[0] = ((long) iL[0]); + long[] callResult_311 = instance.getMachine().call(48, callArgs_311); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + label_289: { + iL[38] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 536); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_289; + } + iL[24] = iL[38]; + label_290: { + iL[37] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 540); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[37]) != 0) { + break label_290; + } + iL[24] = (iL[37] + -12); + label_291: while (true) { + label_292: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) (iL[24] + 11) < 0 ? (iL[24] + 11) : (iL[24] + 11) + 0), -1) != 0) { + break label_292; + } + long[] callArgs_312 = new long[1]; + callArgs_312[0] = ((long) memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0)); + instance.getMachine().call(1777, callArgs_312); + } + iL[37] = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[38], iL[24]); + iL[24] = (iL[24] + -12); + if (iL[37] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_291; + } + break; + } + iL[24] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 536); + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 540, (int) iL[38]); + long[] callArgs_313 = new long[1]; + callArgs_313[0] = ((long) iL[24]); + instance.getMachine().call(1777, callArgs_313); + } + iL[24] = memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0); + } while (false); + return _hs[0]; + } + + private static int func_51__h0(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_25: { + label_26: { + label_27: { + label_28: { + label_29: { + label_30: { + label_31: { + label_32: { + label_33: { + label_34: { + label_35: { + label_36: { + label_37: { + label_38: { + label_39: { + int _d2 = func_51__h2(iL, lL, memory, instance); + if (_d2 == 1) + break label_38; + if (_d2 == 2) + break label_37; + if (_d2 == 3) + break label_36; + if (_d2 == 4) + break label_35; + if (_d2 == 5) + break label_34; + if (_d2 == 6) + break label_33; + if (_d2 == 7) + break label_32; + if (_d2 == 8) + break label_31; + if (_d2 == 9) + break label_30; + if (_d2 == 10) + break label_29; + if (_d2 == 11) + break label_28; + if (_d2 == 12) + break label_26; + if (_d2 == 13) + break label_25; + if (_d2 == 14) + break label_27; + if (_d2 >= 10000) { + _hs[0] = (_d2 - 10000); + break _hb; + } + } + label_79: { + label_80: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1]) != 0) { + break label_80; + } + long[] callArgs_70 = new long[2]; + callArgs_70[1] = ((long) (iL[2] + 36)); + callArgs_70[0] = ((long) iL[1]); + long[] callResult_70 = instance.getMachine().call(131, callArgs_70); + iL[1] = ((int) callResult_70[0]); + break label_79; + } + iL[1] = -1; + if (memory.readInt((int) (iL[2] + 56) < 0 ? (iL[2] + 56) : (iL[2] + 56) + 0) != 0) { + break label_79; + } + iL[1] = memory.readInt((int) (iL[2] + 60) < 0 ? (iL[2] + 60) : (iL[2] + 60) + 0); + } + long[] callArgs_71 = new long[2]; + callArgs_71[1] = ((long) 29); + callArgs_71[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_71); + long[] callArgs_72 = new long[3]; + callArgs_72[2] = ((long) 1695); + callArgs_72[1] = ((long) iL[1]); + callArgs_72[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_72); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_73 = new long[2]; + callArgs_73[1] = ((long) 3); + callArgs_73[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_73); + long[] callArgs_74 = new long[2]; + callArgs_74[1] = ((long) (iL[2] + 48)); + callArgs_74[0] = ((long) iL[0]); + instance.getMachine().call(62, callArgs_74); + long[] callArgs_75 = new long[3]; + callArgs_75[2] = ((long) (iL[2] + 152)); + callArgs_75[1] = ((long) iL[1]); + callArgs_75[0] = ((long) iL[0]); + instance.getMachine().call(55, callArgs_75); + long[] callArgs_76 = new long[2]; + callArgs_76[1] = ((long) 11); + callArgs_76[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_76); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_77 = new long[2]; + callArgs_77[1] = ((long) (iL[2] + 36)); + callArgs_77[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_77 = instance.getMachine().call(124, callArgs_77); + iL[1] = ((int) callResult_77[0]); + long[] callArgs_78 = new long[2]; + callArgs_78[1] = ((long) (iL[2] + 72)); + callArgs_78[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_78 = instance.getMachine().call(124, callArgs_78); + iL[2] = ((int) callResult_78[0]); + long[] callArgs_79 = new long[2]; + callArgs_79[1] = ((long) 206); + callArgs_79[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_79); + long[] callArgs_80 = new long[3]; + callArgs_80[2] = ((long) 2237); + callArgs_80[1] = ((long) iL[1]); + callArgs_80[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_80); + long[] callArgs_81 = new long[3]; + callArgs_81[2] = ((long) 2260); + callArgs_81[1] = ((long) iL[2]); + callArgs_81[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_81); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_82 = new long[2]; + callArgs_82[1] = ((long) (iL[2] + 36)); + callArgs_82[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_82 = instance.getMachine().call(127, callArgs_82); + iL[2] = ((int) callResult_82[0]); + long[] callArgs_83 = new long[2]; + callArgs_83[1] = ((long) 205); + callArgs_83[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_83); + long[] callArgs_84 = new long[3]; + callArgs_84[2] = ((long) 6996); + callArgs_84[1] = ((long) iL[2]); + callArgs_84[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_84); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 132, (byte) (1)); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_85 = new long[2]; + callArgs_85[1] = ((long) (iL[2] + 36)); + callArgs_85[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_85 = instance.getMachine().call(124, callArgs_85); + iL[2] = ((int) callResult_85[0]); + long[] callArgs_86 = new long[2]; + callArgs_86[1] = ((long) 207); + callArgs_86[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_86); + long[] callArgs_87 = new long[3]; + callArgs_87[2] = ((long) 2360); + callArgs_87[1] = ((long) iL[2]); + callArgs_87[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_87); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_88 = new long[2]; + callArgs_88[1] = ((long) (iL[2] + 36)); + callArgs_88[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_88 = instance.getMachine().call(124, callArgs_88); + iL[2] = ((int) callResult_88[0]); + long[] callArgs_89 = new long[2]; + callArgs_89[1] = ((long) 56); + callArgs_89[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_89); + long[] callArgs_90 = new long[3]; + callArgs_90[2] = ((long) 2310); + callArgs_90[1] = ((long) iL[2]); + callArgs_90[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_90); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_91 = new long[2]; + callArgs_91[1] = ((long) (iL[2] + 72)); + callArgs_91[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_91 = instance.getMachine().call(127, callArgs_91); + iL[1] = ((int) callResult_91[0]); + long[] callArgs_92 = new long[2]; + callArgs_92[1] = ((long) (iL[2] + 36)); + callArgs_92[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_92 = instance.getMachine().call(124, callArgs_92); + iL[2] = ((int) callResult_92[0]); + long[] callArgs_93 = new long[2]; + callArgs_93[1] = ((long) 204); + callArgs_93[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_93); + long[] callArgs_94 = new long[3]; + callArgs_94[2] = ((long) 6939); + callArgs_94[1] = ((long) iL[1]); + callArgs_94[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_94); + long[] callArgs_95 = new long[3]; + callArgs_95[2] = ((long) 2329); + callArgs_95[1] = ((long) iL[2]); + callArgs_95[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_95); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 132, (byte) (1)); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_96 = new long[2]; + callArgs_96[1] = ((long) (iL[2] + 36)); + callArgs_96[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_96 = instance.getMachine().call(124, callArgs_96); + iL[2] = ((int) callResult_96[0]); + long[] callArgs_97 = new long[2]; + callArgs_97[1] = ((long) 55); + callArgs_97[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_97); + long[] callArgs_98 = new long[3]; + callArgs_98[2] = ((long) 2379); + callArgs_98[1] = ((long) iL[2]); + callArgs_98[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_98); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_99 = new long[2]; + callArgs_99[1] = ((long) (iL[2] + 36)); + callArgs_99[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_99 = instance.getMachine().call(123, callArgs_99); + iL[1] = ((int) callResult_99[0]); + long[] callArgs_100 = new long[2]; + callArgs_100[1] = ((long) (iL[2] + 72)); + callArgs_100[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_100 = instance.getMachine().call(123, callArgs_100); + iL[2] = ((int) callResult_100[0]); + long[] callArgs_101 = new long[2]; + callArgs_101[1] = ((long) 210); + callArgs_101[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_101); + long[] callArgs_102 = new long[3]; + callArgs_102[2] = ((long) 17241); + callArgs_102[1] = ((long) iL[1]); + callArgs_102[0] = ((long) iL[0]); + instance.getMachine().call(64, callArgs_102); + long[] callArgs_103 = new long[3]; + callArgs_103[2] = ((long) 17271); + callArgs_103[1] = ((long) iL[2]); + callArgs_103[0] = ((long) iL[0]); + instance.getMachine().call(64, callArgs_103); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_104 = new long[2]; + callArgs_104[1] = ((long) (iL[2] + 36)); + callArgs_104[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_104 = instance.getMachine().call(128, callArgs_104); + iL[2] = ((int) callResult_104[0]); + long[] callArgs_105 = new long[2]; + callArgs_105[1] = ((long) 209); + callArgs_105[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_105); + long[] callArgs_106 = new long[3]; + callArgs_106[2] = ((long) 6978); + callArgs_106[1] = ((long) iL[2]); + callArgs_106[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_106); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_107 = new long[2]; + callArgs_107[1] = ((long) (iL[2] + 72)); + callArgs_107[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_107 = instance.getMachine().call(123, callArgs_107); + iL[1] = ((int) callResult_107[0]); + long[] callArgs_108 = new long[2]; + callArgs_108[1] = ((long) (iL[2] + 36)); + callArgs_108[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_108 = instance.getMachine().call(128, callArgs_108); + iL[2] = ((int) callResult_108[0]); + long[] callArgs_109 = new long[2]; + callArgs_109[1] = ((long) 208); + callArgs_109[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_109); + long[] callArgs_110 = new long[3]; + callArgs_110[2] = ((long) 6959); + callArgs_110[1] = ((long) iL[2]); + callArgs_110[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_110); + long[] callArgs_111 = new long[3]; + callArgs_111[2] = ((long) 17302); + callArgs_111[1] = ((long) iL[1]); + callArgs_111[0] = ((long) iL[0]); + instance.getMachine().call(64, callArgs_111); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_112 = new long[2]; + callArgs_112[1] = ((long) (iL[2] + 36)); + callArgs_112[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_112 = instance.getMachine().call(123, callArgs_112); + iL[2] = ((int) callResult_112[0]); + long[] callArgs_113 = new long[2]; + callArgs_113[1] = ((long) 211); + callArgs_113[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_113); + long[] callArgs_114 = new long[3]; + callArgs_114[2] = ((long) 2008); + callArgs_114[1] = ((long) iL[2]); + callArgs_114[0] = ((long) iL[0]); + instance.getMachine().call(64, callArgs_114); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_115 = new long[2]; + callArgs_115[1] = ((long) (iL[2] + 36)); + callArgs_115[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_115 = instance.getMachine().call(123, callArgs_115); + iL[2] = ((int) callResult_115[0]); + long[] callArgs_116 = new long[2]; + callArgs_116[1] = ((long) 212); + callArgs_116[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_116); + long[] callArgs_117 = new long[3]; + callArgs_117[2] = ((long) 1986); + callArgs_117[1] = ((long) iL[2]); + callArgs_117[0] = ((long) iL[0]); + instance.getMachine().call(64, callArgs_117); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_118 = new long[2]; + callArgs_118[1] = ((long) (iL[2] + 36)); + callArgs_118[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_118 = instance.getMachine().call(123, callArgs_118); + iL[2] = ((int) callResult_118[0]); + long[] callArgs_119 = new long[2]; + callArgs_119[1] = ((long) 213); + callArgs_119[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_119); + long[] callArgs_120 = new long[3]; + callArgs_120[2] = ((long) 1919); + callArgs_120[1] = ((long) iL[2]); + callArgs_120[0] = ((long) iL[0]); + instance.getMachine().call(64, callArgs_120); + { + _hs[0] = 23; + break _hb; + } + } + long[] callArgs_121 = new long[2]; + callArgs_121[1] = ((long) (iL[2] + 36)); + callArgs_121[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_121 = instance.getMachine().call(123, callArgs_121); + iL[2] = ((int) callResult_121[0]); + long[] callArgs_122 = new long[2]; + callArgs_122[1] = ((long) 214); + callArgs_122[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_122); + long[] callArgs_123 = new long[3]; + callArgs_123[2] = ((long) 2086); + callArgs_123[1] = ((long) iL[2]); + callArgs_123[0] = ((long) iL[0]); + instance.getMachine().call(64, callArgs_123); + { + _hs[0] = 23; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_114__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + iL[7] = iL[0]; + iL[8] = (iL[1] - iL[7]); + iL[9] = (iL[8] >> 2); + switch(iL[9]) { + case 0: + { + { + _hs[0] = 1; + break _hb; + } + } + case 1: + { + { + _hs[0] = 1; + break _hb; + } + } + case 2: + { + break label_11; + } + case 3: + { + break label_7; + } + case 4: + { + break label_10; + } + case 5: + { + break label_9; + } + default: + { + break label_8; + } + } + } + label_12: { + iL[10] = (iL[1] + -4); + iL[9] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[11] = memory.readInt((int) (iL[9] + 20) < 0 ? (iL[9] + 20) : (iL[9] + 20) + 0); + iL[8] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0); + iL[12] = memory.readInt((int) (iL[8] + 20) < 0 ? (iL[8] + 20) : (iL[8] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[11], iL[12]) != 0) { + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[12], iL[11]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[9] + 24) < 0 ? (iL[9] + 24) : (iL[9] + 24) + 0), memory.readInt((int) (iL[8] + 24) < 0 ? (iL[8] + 24) : (iL[8] + 24) + 0)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + } + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) iL[9]); + memory.writeI32((int) iL[10] < 0 ? iL[10] : iL[10] + 0, (int) iL[8]); + { + _hs[0] = 4; + break _hb; + } + } + iL[11] = (iL[7] + 4); + iL[9] = (iL[7] + 8); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) iL[9]); + callArgs_0[1] = ((long) iL[11]); + callArgs_0[0] = ((long) iL[7]); + instance.getMachine().call(117, callArgs_0); + label_13: { + iL[12] = (iL[1] + -4); + iL[8] = memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0); + iL[13] = memory.readInt((int) (iL[8] + 20) < 0 ? (iL[8] + 20) : (iL[8] + 20) + 0); + iL[10] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 8); + iL[0] = memory.readInt((int) (iL[10] + 20) < 0 ? (iL[10] + 20) : (iL[10] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[13], iL[0]) != 0) { + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[0], iL[13]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[8] + 24) < 0 ? (iL[8] + 24) : (iL[8] + 24) + 0), memory.readInt((int) (iL[10] + 24) < 0 ? (iL[10] + 24) : (iL[10] + 24) + 0)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) iL[8]); + memory.writeI32((int) iL[12] < 0 ? iL[12] : iL[12] + 0, (int) iL[10]); + label_14: { + iL[9] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0); + iL[10] = memory.readInt((int) (iL[9] + 20) < 0 ? (iL[9] + 20) : (iL[9] + 20) + 0); + iL[8] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0); + iL[11] = memory.readInt((int) (iL[8] + 20) < 0 ? (iL[8] + 20) : (iL[8] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[10], iL[11]) != 0) { + break label_14; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[10]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[9] + 24) < 0 ? (iL[9] + 24) : (iL[9] + 24) + 0), memory.readInt((int) (iL[8] + 24) < 0 ? (iL[8] + 24) : (iL[8] + 24) + 0)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + } + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 8, (int) iL[8]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 4, (int) iL[9]); + label_15: { + iL[10] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 20); + iL[8] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0); + iL[11] = memory.readInt((int) (iL[8] + 20) < 0 ? (iL[8] + 20) : (iL[8] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[10], iL[11]) != 0) { + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[10]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[9] + 24) < 0 ? (iL[9] + 24) : (iL[9] + 24) + 0), memory.readInt((int) (iL[8] + 24) < 0 ? (iL[8] + 24) : (iL[8] + 24) + 0)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + } + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 4, (int) iL[8]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) iL[9]); + { + _hs[0] = 4; + break _hb; + } + } + long[] callArgs_1 = new long[5]; + callArgs_1[4] = ((long) (iL[1] + -4)); + callArgs_1[3] = ((long) (iL[7] + 12)); + callArgs_1[2] = ((long) (iL[7] + 8)); + callArgs_1[1] = ((long) (iL[7] + 4)); + callArgs_1[0] = ((long) iL[7]); + instance.getMachine().call(118, callArgs_1); + { + _hs[0] = 4; + break _hb; + } + } + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[8], 95) != 0) { + break label_16; + } + iL[9] = (iL[7] + 4); + iL[8] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1], iL[7]) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1], iL[9])); + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[3] & 1)) != 0) { + break label_17; + } + if (iL[8] != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[14] = 0; + iL[15] = iL[7]; + label_18: while (true) { + iL[8] = iL[15]; + iL[15] = iL[9]; + label_19: { + label_20: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 4); + iL[10] = memory.readInt((int) (iL[12] + 20) < 0 ? (iL[12] + 20) : (iL[12] + 20) + 0); + iL[9] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[11] = memory.readInt((int) (iL[9] + 20) < 0 ? (iL[9] + 20) : (iL[9] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[10], iL[11]) != 0) { + break label_20; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[10]) != 0) { + break label_19; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[12] + 24) < 0 ? (iL[12] + 24) : (iL[12] + 24) + 0), memory.readInt((int) (iL[9] + 24) < 0 ? (iL[9] + 24) : (iL[9] + 24) + 0)) != 0) { + break label_19; + } + } + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 4, (int) iL[9]); + iL[11] = iL[7]; + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[7], iL[8]) != 0) { + break label_21; + } + iL[9] = iL[14]; + label_22: while (true) { + label_23: { + iL[13] = memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 20); + iL[11] = (iL[7] + iL[9]); + iL[10] = memory.readInt((int) (iL[11] + -4) < 0 ? (iL[11] + -4) : (iL[11] + -4) + 0); + iL[0] = memory.readInt((int) (iL[10] + 20) < 0 ? (iL[10] + 20) : (iL[10] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[13], iL[0]) != 0) { + break label_23; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[0], iL[13]) != 0) { + break label_21; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 24), memory.readInt((int) (iL[10] + 24) < 0 ? (iL[10] + 24) : (iL[10] + 24) + 0)) != 0) { + break label_23; + } + iL[11] = iL[8]; + break label_21; + } + iL[8] = (iL[8] + -4); + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) iL[10]); + iL[9] = (iL[9] + -4); + if (iL[9] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_22; + } + break; + } + iL[11] = iL[7]; + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) iL[12]); + } + iL[14] = (iL[14] + 4); + iL[9] = (iL[15] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[1], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + { + _hs[0] = 1; + break _hb; + } + } + } + if (iL[8] != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[13] = (iL[7] + -4); + label_24: while (true) { + iL[8] = iL[7]; + iL[7] = iL[9]; + label_25: { + label_26: { + iL[10] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 4); + iL[9] = memory.readInt((int) (iL[10] + 20) < 0 ? (iL[10] + 20) : (iL[10] + 20) + 0); + iL[8] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[11] = memory.readInt((int) (iL[8] + 20) < 0 ? (iL[8] + 20) : (iL[8] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[9], iL[11]) != 0) { + break label_26; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[9]) != 0) { + break label_25; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[10] + 24) < 0 ? (iL[10] + 24) : (iL[10] + 24) + 0), memory.readInt((int) (iL[8] + 24) < 0 ? (iL[8] + 24) : (iL[8] + 24) + 0)) != 0) { + break label_25; + } + } + iL[9] = iL[13]; + label_27: { + label_28: while (true) { + memory.writeI32((int) (iL[9] + 8) < 0 ? (iL[9] + 8) : (iL[9] + 8) + 0, (int) iL[8]); + label_29: { + iL[11] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 20); + iL[8] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0); + iL[12] = memory.readInt((int) (iL[8] + 20) < 0 ? (iL[8] + 20) : (iL[8] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[11], iL[12]) != 0) { + break label_29; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[12], iL[11]) != 0) { + break label_27; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 24), memory.readInt((int) (iL[8] + 24) < 0 ? (iL[8] + 24) : (iL[8] + 24) + 0)) != 0) { + break label_27; + } + } + iL[9] = (iL[9] + -4); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_28; + } + } + memory.writeI32((int) (iL[9] + 4) < 0 ? (iL[9] + 4) : (iL[9] + 4) + 0, (int) iL[10]); + } + iL[13] = (iL[13] + 4); + iL[9] = (iL[7] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[1], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_24; + } + { + _hs[0] = 1; + break _hb; + } + } + } + label_30: { + if (iL[2] != 0) { + break label_30; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1], iL[7]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[5] = ((iL[9] + -2) >>> 1); + iL[10] = iL[5]; + label_31: while (true) { + label_32: { + iL[13] = iL[10]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[5], iL[13]) != 0) { + break label_32; + } + iL[10] = (iL[7] + (iL[13] << 2)); + iL[11] = (iL[13] << 1); + iL[0] = (iL[11] | 1); + iL[12] = (iL[7] + (iL[0] << 2)); + label_33: { + label_34: { + iL[11] = (iL[11] + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[11], iL[9]) != 0) { + break label_34; + } + iL[11] = iL[0]; + break label_33; + } + label_35: { + iL[2] = memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0); + iL[15] = memory.readInt((int) (iL[2] + 20) < 0 ? (iL[2] + 20) : (iL[2] + 20) + 0); + iL[3] = memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 4); + iL[14] = memory.readInt((int) (iL[3] + 20) < 0 ? (iL[3] + 20) : (iL[3] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[15], iL[14]) != 0) { + break label_35; + } + label_36: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[14], iL[15]) != 0) { + break label_36; + } + iL[11] = iL[0]; + break label_33; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) (iL[2] + 24) < 0 ? (iL[2] + 24) : (iL[2] + 24) + 0), memory.readInt((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)) != 0) { + break label_35; + } + iL[11] = iL[0]; + break label_33; + } + iL[12] = (iL[12] + 4); + } + iL[0] = memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0); + iL[14] = memory.readInt((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0); + iL[15] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[2] = memory.readInt((int) (iL[15] + 20) < 0 ? (iL[15] + 20) : (iL[15] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[14], iL[2]) != 0) { + break label_32; + } + label_37: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[2], iL[14]) != 0) { + break label_37; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) (iL[0] + 24) < 0 ? (iL[0] + 24) : (iL[0] + 24) + 0), memory.readInt((int) (iL[15] + 24) < 0 ? (iL[15] + 24) : (iL[15] + 24) + 0)) != 0) { + break label_32; + } + } + memory.writeI32((int) iL[10] < 0 ? iL[10] : iL[10] + 0, (int) iL[0]); + label_38: { + label_39: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[5], iL[11]) != 0) { + break label_39; + } + iL[10] = iL[12]; + break label_38; + } + label_40: while (true) { + iL[11] = (iL[11] << 1); + iL[0] = (iL[11] | 1); + iL[10] = (iL[7] + (iL[0] << 2)); + label_41: { + label_42: { + iL[11] = (iL[11] + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[11], iL[9]) != 0) { + break label_42; + } + iL[11] = iL[0]; + break label_41; + } + label_43: { + iL[3] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[14] = memory.readInt((int) (iL[3] + 20) < 0 ? (iL[3] + 20) : (iL[3] + 20) + 0); + iL[4] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 4); + iL[2] = memory.readInt((int) (iL[4] + 20) < 0 ? (iL[4] + 20) : (iL[4] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[14], iL[2]) != 0) { + break label_43; + } + label_44: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[2], iL[14]) != 0) { + break label_44; + } + iL[11] = iL[0]; + break label_41; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0), memory.readInt((int) (iL[4] + 24) < 0 ? (iL[4] + 24) : (iL[4] + 24) + 0)) != 0) { + break label_43; + } + iL[11] = iL[0]; + break label_41; + } + iL[10] = (iL[10] + 4); + } + label_45: { + iL[0] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[14] = memory.readInt((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0); + iL[2] = memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[14], iL[2]) != 0) { + break label_45; + } + iL[10] = iL[12]; + break label_38; + } + label_46: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[2], iL[14]) != 0) { + break label_46; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[0] + 24) < 0 ? (iL[0] + 24) : (iL[0] + 24) + 0), memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 24)) != 0) { + break label_46; + } + iL[10] = iL[12]; + break label_38; + } + memory.writeI32((int) iL[12] < 0 ? iL[12] : iL[12] + 0, (int) iL[0]); + iL[12] = iL[10]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[5], iL[11]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_40; + } + break; + } + } + memory.writeI32((int) iL[10] < 0 ? iL[10] : iL[10] + 0, (int) iL[15]); + } + iL[10] = (iL[13] + -1); + if (iL[13] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_31; + } + break; + } + iL[9] = (iL[8] >>> 2); + label_47: while (true) { + iL[13] = iL[9]; + iL[0] = ((iL[13] + -2) >>> 1); + iL[5] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0); + iL[8] = 0; + iL[9] = iL[7]; + label_48: while (true) { + iL[10] = (iL[8] << 1); + iL[12] = (iL[10] | 1); + iL[11] = iL[9]; + iL[9] = (((iL[8] << 2) + iL[11]) + 4); + label_49: { + label_50: { + iL[8] = (iL[10] + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[8], iL[13]) != 0) { + break label_50; + } + iL[8] = iL[12]; + break label_49; + } + label_51: { + iL[14] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0); + iL[10] = memory.readInt((int) (iL[14] + 20) < 0 ? (iL[14] + 20) : (iL[14] + 20) + 0); + iL[2] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 4); + iL[15] = memory.readInt((int) (iL[2] + 20) < 0 ? (iL[2] + 20) : (iL[2] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[10], iL[15]) != 0) { + break label_51; + } + label_52: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[15], iL[10]) != 0) { + break label_52; + } + iL[8] = iL[12]; + break label_49; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) (iL[14] + 24) < 0 ? (iL[14] + 24) : (iL[14] + 24) + 0), memory.readInt((int) (iL[2] + 24) < 0 ? (iL[2] + 24) : (iL[2] + 24) + 0)) != 0) { + break label_51; + } + iL[8] = iL[12]; + break label_49; + } + iL[9] = (iL[9] + 4); + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[8], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_48; + } + break; + } + label_53: { + label_54: { + iL[1] = (iL[1] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[1], iL[9]) != 0) { + break label_54; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) iL[5]); + break label_53; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0)); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[5]); + iL[8] = ((iL[9] - iL[7]) + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[8], 5) != 0) { + break label_53; + } + label_55: { + iL[12] = ((iL[8] >>> 2) + -2); + iL[10] = (iL[12] >>> 1); + iL[8] = (iL[7] + (iL[10] << 2)); + iL[11] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[15] = memory.readInt((int) (iL[11] + 20) < 0 ? (iL[11] + 20) : (iL[11] + 20) + 0); + iL[0] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0); + iL[14] = memory.readInt((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[15], iL[14]) != 0) { + break label_55; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[14], iL[15]) != 0) { + break label_53; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[11] + 24) < 0 ? (iL[11] + 24) : (iL[11] + 24) + 0), memory.readInt((int) (iL[0] + 24) < 0 ? (iL[0] + 24) : (iL[0] + 24) + 0)) != 0) { + break label_53; + } + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) iL[11]); + label_56: { + label_57: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[12], 2) != 0) { + break label_57; + } + iL[11] = iL[8]; + break label_56; + } + label_58: while (true) { + label_59: { + iL[12] = (iL[10] + -1); + iL[10] = (iL[12] >>> 1); + iL[11] = (iL[7] + (iL[10] << 2)); + iL[9] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0); + iL[15] = memory.readInt((int) (iL[9] + 20) < 0 ? (iL[9] + 20) : (iL[9] + 20) + 0); + iL[14] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[15], iL[14]) != 0) { + break label_59; + } + label_60: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[14], iL[15]) != 0) { + break label_60; + } + iL[11] = iL[8]; + break label_56; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) (iL[9] + 24) < 0 ? (iL[9] + 24) : (iL[9] + 24) + 0), memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 24)) != 0) { + break label_59; + } + iL[11] = iL[8]; + break label_56; + } + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) iL[9]); + iL[8] = iL[11]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[12], 1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_58; + } + break; + } + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) iL[0]); + } + iL[9] = (iL[13] + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[13], 2) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_47; + } + { + _hs[0] = 1; + break _hb; + } + } + } + iL[10] = ((iL[9] >>> 1) << 2); + iL[9] = (iL[7] + iL[10]); + label_61: { + label_62: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[8], 513) != 0) { + break label_62; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) iL[5]); + callArgs_2[1] = ((long) iL[9]); + callArgs_2[0] = ((long) iL[7]); + instance.getMachine().call(117, callArgs_2); + iL[8] = (iL[7] + 4); + iL[11] = (iL[9] + -4); + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) iL[4]); + callArgs_3[1] = ((long) iL[11]); + callArgs_3[0] = ((long) iL[8]); + instance.getMachine().call(117, callArgs_3); + iL[8] = (iL[8] + iL[10]); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) iL[6]); + callArgs_4[1] = ((long) iL[8]); + callArgs_4[0] = ((long) (iL[7] + 8)); + instance.getMachine().call(117, callArgs_4); + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) iL[8]); + callArgs_5[1] = ((long) iL[9]); + callArgs_5[0] = ((long) iL[11]); + instance.getMachine().call(117, callArgs_5); + iL[8] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0)); + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) iL[8]); + break label_61; + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) iL[5]); + callArgs_6[1] = ((long) iL[7]); + callArgs_6[0] = ((long) iL[9]); + instance.getMachine().call(117, callArgs_6); + } + iL[2] = (iL[2] + -1); + label_63: { + iL[16] = (iL[3] & 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[16]) != 0) { + break label_63; + } + iL[13] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0); + iL[8] = memory.readInt((int) (iL[13] + 20) < 0 ? (iL[13] + 20) : (iL[13] + 20) + 0); + { + _hs[0] = 2; + break _hb; + } + } + iL[10] = memory.readInt((int) (iL[7] + -4) < 0 ? (iL[7] + -4) : (iL[7] + -4) + 0); + iL[9] = memory.readInt((int) (iL[10] + 20) < 0 ? (iL[10] + 20) : (iL[10] + 20) + 0); + iL[13] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0); + iL[8] = memory.readInt((int) (iL[13] + 20) < 0 ? (iL[13] + 20) : (iL[13] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[9], iL[8]) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + label_64: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[9]) != 0) { + break label_64; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[10] + 24) < 0 ? (iL[10] + 24) : (iL[10] + 24) + 0), memory.readInt((int) (iL[13] + 24) < 0 ? (iL[13] + 24) : (iL[13] + 24) + 0)) != 0) { + break label_64; + } + iL[8] = iL[9]; + { + _hs[0] = 2; + break _hb; + } + } + label_65: { + iL[12] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0); + iL[11] = memory.readInt((int) (iL[12] + 20) < 0 ? (iL[12] + 20) : (iL[12] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[8], iL[11]) != 0) { + break label_65; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[8]) != 0) { + break _hb; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(memory.readInt((int) (iL[13] + 24) < 0 ? (iL[13] + 24) : (iL[13] + 24) + 0), memory.readInt((int) (iL[12] + 24) < 0 ? (iL[12] + 24) : (iL[12] + 24) + 0)) != 0) { + break _hb; + } + } + iL[0] = (iL[7] + 4); + iL[10] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 4); + iL[9] = memory.readInt((int) (iL[10] + 20) < 0 ? (iL[10] + 20) : (iL[10] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[8], iL[9]) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + label_66: while (true) { + label_67: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[9], iL[8]) != 0) { + break label_67; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 24), memory.readInt((int) (iL[10] + 24) < 0 ? (iL[10] + 24) : (iL[10] + 24) + 0)) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + } + iL[0] = (iL[0] + 4); + iL[10] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[9] = memory.readInt((int) (iL[10] + 20) < 0 ? (iL[10] + 20) : (iL[10] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[8], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_66; + } + { + _hs[0] = 3; + break _hb; + } + } + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) (iL[1] + -4)); + callArgs_7[1] = ((long) (iL[7] + 4)); + callArgs_7[0] = ((long) iL[7]); + instance.getMachine().call(117, callArgs_7); + { + _hs[0] = 1; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_194__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_9: { + label_10: { + label_11: { + label_12: { + int _d1 = func_194__h1(iL, memory, instance); + if (_d1 == 1) + break label_11; + if (_d1 == 2) + break label_9; + if (_d1 == 3) + break label_10; + if (_d1 >= 10000) { + _hs[0] = (_d1 - 10000); + break _hb; + } + } + { + iL[0] = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF)); + _hs[0] = 8; + break _hb; + } + } + { + iL[0] = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 8) & 0xFF)); + _hs[0] = 8; + break _hb; + } + } + { + iL[0] = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 2) & 0xFF)); + _hs[0] = 8; + break _hb; + } + } + { + iL[0] = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 3) & 0xFF)); + _hs[0] = 8; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_450__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_27: { + label_28: { + label_29: { + label_30: { + label_31: { + label_32: { + label_33: { + label_34: { + label_35: { + label_36: { + label_37: { + label_38: { + label_39: { + label_40: { + label_41: { + label_42: { + int _d2 = func_450__h2(iL, memory, instance); + if (_d2 == 1) + break label_41; + if (_d2 == 2) + break label_40; + if (_d2 == 3) + break label_39; + if (_d2 == 4) + break label_38; + if (_d2 == 5) + break label_37; + if (_d2 == 6) + break label_36; + if (_d2 == 7) + break label_35; + if (_d2 == 8) + break label_34; + if (_d2 == 9) + break label_33; + if (_d2 == 10) + break label_32; + if (_d2 == 11) + break label_31; + if (_d2 == 12) + break label_30; + if (_d2 == 13) + break label_29; + if (_d2 == 14) + break label_28; + if (_d2 == 15) + break label_27; + if (_d2 >= 10000) { + _hs[0] = (_d2 - 10000); + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_27 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 296)); + int ciFuncId_27 = instance.table(0).requiredRef(ciTableIdx_27); + com.dylibso.chicory.runtime.Instance ciRefInstance_27 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_27), instance); + if (!ciRefInstance_27.type(ciRefInstance_27.functionType(ciFuncId_27)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) iL[1]); + callArgs_27[0] = ((long) iL[0]); + long[] callResult_27 = ciRefInstance_27.getMachine().call(ciFuncId_27, callArgs_27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_27[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_28 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 96)); + int ciFuncId_28 = instance.table(0).requiredRef(ciTableIdx_28); + com.dylibso.chicory.runtime.Instance ciRefInstance_28 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_28), instance); + if (!ciRefInstance_28.type(ciRefInstance_28.functionType(ciFuncId_28)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) iL[1]); + callArgs_28[0] = ((long) iL[0]); + long[] callResult_28 = ciRefInstance_28.getMachine().call(ciFuncId_28, callArgs_28); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_28[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_29 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 100)); + int ciFuncId_29 = instance.table(0).requiredRef(ciTableIdx_29); + com.dylibso.chicory.runtime.Instance ciRefInstance_29 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_29), instance); + if (!ciRefInstance_29.type(ciRefInstance_29.functionType(ciFuncId_29)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) iL[1]); + callArgs_29[0] = ((long) iL[0]); + long[] callResult_29 = ciRefInstance_29.getMachine().call(ciFuncId_29, callArgs_29); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_29[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_30 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 104)); + int ciFuncId_30 = instance.table(0).requiredRef(ciTableIdx_30); + com.dylibso.chicory.runtime.Instance ciRefInstance_30 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_30), instance); + if (!ciRefInstance_30.type(ciRefInstance_30.functionType(ciFuncId_30)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) iL[1]); + callArgs_30[0] = ((long) iL[0]); + long[] callResult_30 = ciRefInstance_30.getMachine().call(ciFuncId_30, callArgs_30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_30[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[3] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_31 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 108)); + int ciFuncId_31 = instance.table(0).requiredRef(ciTableIdx_31); + com.dylibso.chicory.runtime.Instance ciRefInstance_31 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_31), instance); + if (!ciRefInstance_31.type(ciRefInstance_31.functionType(ciFuncId_31)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) iL[1]); + callArgs_31[0] = ((long) iL[3]); + long[] callResult_31 = ciRefInstance_31.getMachine().call(ciFuncId_31, callArgs_31); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_31[0])) != 0) { + { + _hs[0] = 25; + break _hb; + } + } + long[] callArgs_32 = new long[4]; + callArgs_32[3] = ((long) (iL[1] + 152)); + callArgs_32[2] = ((long) iL[1]); + callArgs_32[1] = ((long) 4); + callArgs_32[0] = ((long) iL[0]); + instance.getMachine().call(451, callArgs_32); + { + _hs[0] = 24; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_33 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 116)); + int ciFuncId_33 = instance.table(0).requiredRef(ciTableIdx_33); + com.dylibso.chicory.runtime.Instance ciRefInstance_33 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_33), instance); + if (!ciRefInstance_33.type(ciRefInstance_33.functionType(ciFuncId_33)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_33 = new long[2]; + callArgs_33[1] = ((long) iL[1]); + callArgs_33[0] = ((long) iL[0]); + long[] callResult_33 = ciRefInstance_33.getMachine().call(ciFuncId_33, callArgs_33); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_33[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_34 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 120)); + int ciFuncId_34 = instance.table(0).requiredRef(ciTableIdx_34); + com.dylibso.chicory.runtime.Instance ciRefInstance_34 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_34), instance); + if (!ciRefInstance_34.type(ciRefInstance_34.functionType(ciFuncId_34)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_34 = new long[2]; + callArgs_34[1] = ((long) iL[1]); + callArgs_34[0] = ((long) iL[0]); + long[] callResult_34 = ciRefInstance_34.getMachine().call(ciFuncId_34, callArgs_34); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_34[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_35 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 124)); + int ciFuncId_35 = instance.table(0).requiredRef(ciTableIdx_35); + com.dylibso.chicory.runtime.Instance ciRefInstance_35 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_35), instance); + if (!ciRefInstance_35.type(ciRefInstance_35.functionType(ciFuncId_35)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_35 = new long[2]; + callArgs_35[1] = ((long) iL[1]); + callArgs_35[0] = ((long) iL[0]); + long[] callResult_35 = ciRefInstance_35.getMachine().call(ciFuncId_35, callArgs_35); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_35[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_36 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 128)); + int ciFuncId_36 = instance.table(0).requiredRef(ciTableIdx_36); + com.dylibso.chicory.runtime.Instance ciRefInstance_36 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_36), instance); + if (!ciRefInstance_36.type(ciRefInstance_36.functionType(ciFuncId_36)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) iL[1]); + callArgs_36[0] = ((long) iL[0]); + long[] callResult_36 = ciRefInstance_36.getMachine().call(ciFuncId_36, callArgs_36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_36[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_37 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 132)); + int ciFuncId_37 = instance.table(0).requiredRef(ciTableIdx_37); + com.dylibso.chicory.runtime.Instance ciRefInstance_37 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_37), instance); + if (!ciRefInstance_37.type(ciRefInstance_37.functionType(ciFuncId_37)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) iL[1]); + callArgs_37[0] = ((long) iL[0]); + long[] callResult_37 = ciRefInstance_37.getMachine().call(ciFuncId_37, callArgs_37); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_37[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_38 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 136)); + int ciFuncId_38 = instance.table(0).requiredRef(ciTableIdx_38); + com.dylibso.chicory.runtime.Instance ciRefInstance_38 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_38), instance); + if (!ciRefInstance_38.type(ciRefInstance_38.functionType(ciFuncId_38)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_38 = new long[2]; + callArgs_38[1] = ((long) iL[1]); + callArgs_38[0] = ((long) iL[0]); + long[] callResult_38 = ciRefInstance_38.getMachine().call(ciFuncId_38, callArgs_38); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_38[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_39 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 140)); + int ciFuncId_39 = instance.table(0).requiredRef(ciTableIdx_39); + com.dylibso.chicory.runtime.Instance ciRefInstance_39 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_39), instance); + if (!ciRefInstance_39.type(ciRefInstance_39.functionType(ciFuncId_39)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) iL[1]); + callArgs_39[0] = ((long) iL[0]); + long[] callResult_39 = ciRefInstance_39.getMachine().call(ciFuncId_39, callArgs_39); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_39[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_40 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 144)); + int ciFuncId_40 = instance.table(0).requiredRef(ciTableIdx_40); + com.dylibso.chicory.runtime.Instance ciRefInstance_40 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_40), instance); + if (!ciRefInstance_40.type(ciRefInstance_40.functionType(ciFuncId_40)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_40 = new long[2]; + callArgs_40[1] = ((long) iL[1]); + callArgs_40[0] = ((long) iL[0]); + long[] callResult_40 = ciRefInstance_40.getMachine().call(ciFuncId_40, callArgs_40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_40[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_41 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 148)); + int ciFuncId_41 = instance.table(0).requiredRef(ciTableIdx_41); + com.dylibso.chicory.runtime.Instance ciRefInstance_41 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_41), instance); + if (!ciRefInstance_41.type(ciRefInstance_41.functionType(ciFuncId_41)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_41 = new long[2]; + callArgs_41[1] = ((long) iL[1]); + callArgs_41[0] = ((long) iL[0]); + long[] callResult_41 = ciRefInstance_41.getMachine().call(ciFuncId_41, callArgs_41); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_41[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_42 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 152)); + int ciFuncId_42 = instance.table(0).requiredRef(ciTableIdx_42); + com.dylibso.chicory.runtime.Instance ciRefInstance_42 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_42), instance); + if (!ciRefInstance_42.type(ciRefInstance_42.functionType(ciFuncId_42)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_42 = new long[2]; + callArgs_42[1] = ((long) iL[1]); + callArgs_42[0] = ((long) iL[0]); + long[] callResult_42 = ciRefInstance_42.getMachine().call(ciFuncId_42, callArgs_42); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_42[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_43 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 156)); + int ciFuncId_43 = instance.table(0).requiredRef(ciTableIdx_43); + com.dylibso.chicory.runtime.Instance ciRefInstance_43 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_43), instance); + if (!ciRefInstance_43.type(ciRefInstance_43.functionType(ciFuncId_43)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_43 = new long[2]; + callArgs_43[1] = ((long) iL[1]); + callArgs_43[0] = ((long) iL[0]); + long[] callResult_43 = ciRefInstance_43.getMachine().call(ciFuncId_43, callArgs_43); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_43[0])) != 0) { + { + _hs[0] = 24; + break _hb; + } + } + { + _hs[0] = 25; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_455__h0(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[3] = memory.readInt((int) (iL[0] + 296) < 0 ? (iL[0] + 296) : (iL[0] + 296) + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break _hb; + } + iL[5] = (iL[0] + 12); + label_2: while (true) { + label_3: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(4, memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 32)) != 0) { + break label_3; + } + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + iL[6] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 36); + switch(memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 36)) { + case 0: + { + break label_9; + } + case 1: + { + break label_8; + } + case 2: + { + break label_7; + } + default: + { + break label_3; + } + } + } + iL[7] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 40); + iL[8] = memory.readInt((int) (iL[6] + 52) < 0 ? (iL[6] + 52) : (iL[6] + 52) + 0); + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) (iL[6] + 40)); + callArgs_0[0] = ((long) iL[3]); + long[] callResult_0 = instance.getMachine().call(134, callArgs_0); + long[] callArgs_1 = new long[7]; + callArgs_1[6] = ((long) ((int) callResult_0[0])); + callArgs_1[5] = ((long) iL[8]); + callArgs_1[4] = ((long) ((memory.readInt((int) (iL[6] + 56) < 0 ? (iL[6] + 56) : (iL[6] + 56) + 0) - iL[8]) >> 3)); + callArgs_1[3] = ((long) iL[7]); + callArgs_1[2] = ((long) ((memory.readInt((int) (iL[6] + 44) < 0 ? (iL[6] + 44) : (iL[6] + 44) + 0) - iL[7]) >> 3)); + callArgs_1[1] = ((long) (iL[4] + 12)); + callArgs_1[0] = ((long) iL[5]); + long[] callResult_1 = instance.getMachine().call(338, callArgs_1); + iL[6] = ((int) callResult_1[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[6]))); + break label_3; + } + label_10: { + iL[9] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 40); + iL[10] = memory.readInt((int) (iL[6] + 44) < 0 ? (iL[6] + 44) : (iL[6] + 44) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + break label_10; + } + iL[8] = 0; + iL[6] = 0; + break label_4; + } + iL[7] = 0; + iL[6] = 0; + iL[8] = 0; + label_11: while (true) { + iL[11] = ((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 20) & 0xFF); + lL[0] = memory.readLong((int) iL[9] < 0 ? iL[9] : iL[9] + 12); + label_12: { + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[6], iL[7]) != 0) { + break label_13; + } + memory.writeByte((int) iL[6] < 0 ? iL[6] : iL[6] + 8, (byte) (iL[11])); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) lL[0]); + iL[6] = (iL[6] + 12); + break label_12; + } + iL[12] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((iL[6] - iL[8]), 12); + iL[13] = (iL[12] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[13], 357913942) != 0) { + break label_6; + } + label_14: { + label_15: { + iL[7] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((iL[7] - iL[8]), 12); + iL[14] = (iL[7] << 1); + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[7], 178956970) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[14], iL[13]) != 0 ? iL[14] : iL[13]) : 357913941); + if (iL[7] != 0) { + break label_15; + } + iL[14] = 0; + break label_14; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[7], 357913942) != 0) { + break label_5; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) (iL[7] * 12)); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + iL[14] = ((int) callResult_2[0]); + } + iL[13] = (iL[14] + (iL[12] * 12)); + memory.writeByte((int) iL[13] < 0 ? iL[13] : iL[13] + 8, (byte) (iL[11])); + memory.writeLong((int) iL[13] < 0 ? iL[13] : iL[13] + 0, (long) lL[0]); + iL[12] = (iL[7] * 12); + label_16: { + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[6]) != 0) { + break label_17; + } + iL[11] = iL[6]; + iL[8] = iL[13]; + break label_16; + } + iL[7] = iL[13]; + label_18: while (true) { + iL[7] = (iL[7] + -12); + iL[6] = (iL[6] + -12); + memory.writeLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + memory.writeI32((int) (iL[7] + 8) < 0 ? (iL[7] + 8) : (iL[7] + 8) + 0, (int) memory.readInt((int) (iL[6] + 8) < 0 ? (iL[6] + 8) : (iL[6] + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[6]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + iL[11] = iL[8]; + iL[8] = iL[7]; + } + iL[7] = (iL[14] + iL[12]); + iL[6] = (iL[13] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[11]) != 0) { + break label_12; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) iL[11]); + instance.getMachine().call(1777, callArgs_3); + } + iL[9] = (iL[9] + 24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[10], iL[9]) != 0) { + break label_4; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_11; + } + } + iL[7] = ((iL[2] + 576) + 8); + memory.writeByte((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (byte) (((int) memory.read((int) (iL[6] + 60) < 0 ? (iL[6] + 60) : (iL[6] + 60) + 0) & 0xFF))); + lL[0] = memory.readLong((int) (iL[6] + 52) < 0 ? (iL[6] + 52) : (iL[6] + 52) + 0); + memory.writeI32((int) ((iL[2] + 96) + 8) < 0 ? ((iL[2] + 96) + 8) : ((iL[2] + 96) + 8) + 0, (int) memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 576, (long) lL[0]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 96, (long) lL[0]); + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) (iL[2] + 96)); + callArgs_4[1] = ((long) (iL[4] + 12)); + callArgs_4[0] = ((long) iL[5]); + long[] callResult_4 = instance.getMachine().call(340, callArgs_4); + iL[6] = ((int) callResult_4[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[6]))); + break label_3; + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + long[] callArgs_7 = new long[4]; + callArgs_7[3] = ((long) iL[8]); + callArgs_7[2] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((iL[6] - iL[8]), 12)); + callArgs_7[1] = ((long) (iL[4] + 12)); + callArgs_7[0] = ((long) iL[5]); + long[] callResult_7 = instance.getMachine().call(339, callArgs_7); + iL[6] = ((int) callResult_7[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[6]))); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[8]) != 0) { + break label_3; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) iL[8]); + instance.getMachine().call(1777, callArgs_8); + } + iL[4] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 4); + if (iL[4] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_2; + } + break; + } + iL[6] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break _hb; + } + iL[8] = (iL[0] + 12); + iL[13] = (iL[0] + 296); + label_19: while (true) { + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(2, memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 32)) != 0) { + break label_20; + } + label_21: { + label_22: { + label_23: { + label_24: { + label_25: { + iL[7] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 36); + switch(memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 28)) { + case 0: + { + break label_25; + } + case 1: + { + break label_24; + } + case 2: + { + break label_23; + } + case 3: + { + break label_22; + } + case 4: + { + break label_21; + } + default: + { + break label_20; + } + } + } + iL[9] = (iL[6] + 12); + label_26: { + label_27: { + iL[11] = (iL[7] + 44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[11] < 0 ? iL[11] : iL[11] + 0) & 0xFF)) != 0) { + break label_27; + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) (iL[7] + 48)); + callArgs_9[0] = ((long) (iL[2] + 536)); + long[] callResult_9 = instance.getMachine().call(159, callArgs_9); + break label_26; + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) iL[11]); + callArgs_10[0] = ((long) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0)); + long[] callResult_10 = instance.getMachine().call(135, callArgs_10); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) iL[9]); + callArgs_11[1] = ((long) ((int) callResult_10[0])); + callArgs_11[0] = ((long) (iL[2] + 536)); + long[] callResult_11 = instance.getMachine().call(155, callArgs_11); + } + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) (iL[2] + 536)); + callArgs_12[1] = ((long) iL[9]); + callArgs_12[0] = ((long) iL[8]); + long[] callResult_12 = instance.getMachine().call(341, callArgs_12); + iL[7] = ((int) callResult_12[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) (iL[2] + 536)); + long[] callResult_13 = instance.getMachine().call(162, callArgs_13); + break label_20; + } + lL[0] = memory.readLong((int) (iL[7] + 72) < 0 ? (iL[7] + 72) : (iL[7] + 72) + 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 528, (long) lL[0]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 80, (long) lL[0]); + long[] callArgs_14 = new long[4]; + callArgs_14[3] = ((long) (iL[7] + 48)); + callArgs_14[2] = ((long) (iL[2] + 80)); + callArgs_14[1] = ((long) (iL[6] + 12)); + callArgs_14[0] = ((long) iL[8]); + long[] callResult_14 = instance.getMachine().call(345, callArgs_14); + iL[7] = ((int) callResult_14[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + break label_20; + } + long[] callArgs_15 = new long[4]; + callArgs_15[3] = ((long) memory.readInt((int) (iL[7] + 72) < 0 ? (iL[7] + 72) : (iL[7] + 72) + 0)); + callArgs_15[2] = ((long) (iL[7] + 48)); + callArgs_15[1] = ((long) (iL[6] + 12)); + callArgs_15[0] = ((long) iL[8]); + long[] callResult_15 = instance.getMachine().call(346, callArgs_15); + iL[7] = ((int) callResult_15[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + break label_20; + } + lL[0] = memory.readLong((int) (iL[7] + 44) < 0 ? (iL[7] + 44) : (iL[7] + 44) + 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 520, (long) lL[0]); + iL[7] = ((int) memory.read((int) (iL[7] + 52) < 0 ? (iL[7] + 52) : (iL[7] + 52) + 0) & 0xFF); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 88, (long) lL[0]); + long[] callArgs_16 = new long[4]; + callArgs_16[3] = ((long) iL[7]); + callArgs_16[2] = ((long) (iL[2] + 88)); + callArgs_16[1] = ((long) (iL[6] + 12)); + callArgs_16[0] = ((long) iL[8]); + long[] callResult_16 = instance.getMachine().call(347, callArgs_16); + iL[7] = ((int) callResult_16[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + break label_20; + } + iL[9] = (iL[6] + 12); + label_28: { + label_29: { + iL[11] = (iL[7] + 44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[11] < 0 ? iL[11] : iL[11] + 0) & 0xFF)) != 0) { + break label_29; + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) (iL[7] + 48)); + callArgs_17[0] = ((long) (iL[2] + 480)); + long[] callResult_17 = instance.getMachine().call(159, callArgs_17); + break label_28; + } + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) iL[11]); + callArgs_18[0] = ((long) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0)); + long[] callResult_18 = instance.getMachine().call(135, callArgs_18); + long[] callArgs_19 = new long[3]; + callArgs_19[2] = ((long) iL[9]); + callArgs_19[1] = ((long) ((int) callResult_18[0])); + callArgs_19[0] = ((long) (iL[2] + 480)); + long[] callResult_19 = instance.getMachine().call(155, callArgs_19); + } + long[] callArgs_20 = new long[3]; + callArgs_20[2] = ((long) (iL[2] + 480)); + callArgs_20[1] = ((long) iL[9]); + callArgs_20[0] = ((long) iL[8]); + long[] callResult_20 = instance.getMachine().call(350, callArgs_20); + iL[7] = ((int) callResult_20[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) (iL[2] + 480)); + long[] callResult_21 = instance.getMachine().call(162, callArgs_21); + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_19; + } + break; + } + iL[6] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break _hb; + } + iL[9] = (iL[0] + 12); + iL[11] = (iL[0] + 296); + label_30: while (true) { + label_31: { + if (memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 32) != 0) { + break label_31; + } + iL[7] = (iL[6] + 12); + label_32: { + label_33: { + iL[8] = (iL[6] + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[8] < 0 ? iL[8] : iL[8] + 0) & 0xFF)) != 0) { + break label_33; + } + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) (iL[6] + 52)); + callArgs_22[0] = ((long) (iL[2] + 440)); + long[] callResult_22 = instance.getMachine().call(159, callArgs_22); + break label_32; + } + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) iL[8]); + callArgs_23[0] = ((long) memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0)); + long[] callResult_23 = instance.getMachine().call(135, callArgs_23); + long[] callArgs_24 = new long[3]; + callArgs_24[2] = ((long) iL[7]); + callArgs_24[1] = ((long) ((int) callResult_23[0])); + callArgs_24[0] = ((long) (iL[2] + 440)); + long[] callResult_24 = instance.getMachine().call(155, callArgs_24); + } + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) (iL[2] + 440)); + callArgs_25[1] = ((long) iL[7]); + callArgs_25[0] = ((long) iL[9]); + long[] callResult_25 = instance.getMachine().call(341, callArgs_25); + iL[7] = ((int) callResult_25[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) (iL[2] + 440)); + long[] callResult_26 = instance.getMachine().call(162, callArgs_26); + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_30; + } + break; + } + iL[6] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break _hb; + } + iL[8] = (iL[0] + 12); + label_34: while (true) { + label_35: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(5, memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 32)) != 0) { + break label_35; + } + lL[0] = memory.readLong((int) (iL[6] + 80) < 0 ? (iL[6] + 80) : (iL[6] + 80) + 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 432, (long) lL[0]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 72, (long) lL[0]); + long[] callArgs_27 = new long[4]; + callArgs_27[3] = ((long) (iL[6] + 56)); + callArgs_27[2] = ((long) (iL[2] + 72)); + callArgs_27[1] = ((long) (iL[6] + 12)); + callArgs_27[0] = ((long) iL[8]); + long[] callResult_27 = instance.getMachine().call(345, callArgs_27); + iL[7] = ((int) callResult_27[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_34; + } + break; + } + iL[6] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break _hb; + } + iL[8] = (iL[0] + 12); + label_36: while (true) { + label_37: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(7, memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 32)) != 0) { + break label_37; + } + long[] callArgs_28 = new long[4]; + callArgs_28[3] = ((long) memory.readInt((int) (iL[6] + 80) < 0 ? (iL[6] + 80) : (iL[6] + 80) + 0)); + callArgs_28[2] = ((long) (iL[6] + 56)); + callArgs_28[1] = ((long) (iL[6] + 12)); + callArgs_28[0] = ((long) iL[8]); + long[] callResult_28 = instance.getMachine().call(346, callArgs_28); + iL[7] = ((int) callResult_28[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_36; + } + break; + } + iL[6] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break _hb; + } + iL[7] = (iL[0] + 12); + label_38: while (true) { + label_39: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 32)) != 0) { + break label_39; + } + iL[8] = (iL[6] + 48); + lL[0] = memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 424, (long) lL[0]); + iL[9] = ((int) memory.read((int) (iL[6] + 56) < 0 ? (iL[6] + 56) : (iL[6] + 56) + 0) & 0xFF); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 64, (long) lL[0]); + iL[11] = (iL[6] + 12); + long[] callArgs_29 = new long[4]; + callArgs_29[3] = ((long) iL[9]); + callArgs_29[2] = ((long) (iL[2] + 64)); + callArgs_29[1] = ((long) iL[11]); + callArgs_29[0] = ((long) iL[7]); + long[] callResult_29 = instance.getMachine().call(348, callArgs_29); + iL[9] = ((int) callResult_29[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[9]))); + lL[0] = memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 416, (long) lL[0]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 56, (long) lL[0]); + long[] callArgs_30 = new long[3]; + callArgs_30[2] = ((long) (iL[2] + 56)); + callArgs_30[1] = ((long) iL[11]); + callArgs_30[0] = ((long) iL[7]); + long[] callResult_30 = instance.getMachine().call(368, callArgs_30); + iL[8] = ((int) callResult_30[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[8]))); + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) iL[0]); + callArgs_31[0] = ((long) (iL[2] + 360)); + long[] callResult_31 = instance.getMachine().call(447, callArgs_31); + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) (iL[6] + 60)); + callArgs_32[0] = ((long) ((int) callResult_31[0])); + long[] callResult_32 = instance.getMachine().call(453, callArgs_32); + iL[8] = ((int) callResult_32[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[8]))); + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) iL[7]); + long[] callResult_33 = instance.getMachine().call(369, callArgs_33); + iL[8] = ((int) callResult_33[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[8]))); + label_40: { + iL[8] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 400); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[8]) != 0) { + break label_40; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 404, (int) iL[8]); + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) iL[8]); + instance.getMachine().call(1777, callArgs_34); + } + label_41: { + iL[8] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 388); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[8]) != 0) { + break label_41; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 392, (int) iL[8]); + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) iL[8]); + instance.getMachine().call(1777, callArgs_35); + } + label_42: { + iL[8] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 376); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[8]) != 0) { + break label_42; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 380, (int) iL[8]); + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) iL[8]); + instance.getMachine().call(1777, callArgs_36); + } + iL[8] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 364); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[8]) != 0) { + break label_39; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 368, (int) iL[8]); + long[] callArgs_37 = new long[1]; + callArgs_37[0] = ((long) iL[8]); + instance.getMachine().call(1777, callArgs_37); + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_38; + } + break; + } + iL[6] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break _hb; + } + iL[9] = (iL[0] + 12); + iL[11] = (iL[0] + 296); + label_43: while (true) { + label_44: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(10, memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 32)) != 0) { + break label_44; + } + iL[7] = (iL[6] + 12); + label_45: { + label_46: { + iL[8] = (iL[6] + 48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[8] < 0 ? iL[8] : iL[8] + 0) & 0xFF)) != 0) { + break label_46; + } + long[] callArgs_38 = new long[2]; + callArgs_38[1] = ((long) (iL[6] + 52)); + callArgs_38[0] = ((long) (iL[2] + 320)); + long[] callResult_38 = instance.getMachine().call(159, callArgs_38); + break label_45; + } + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) iL[8]); + callArgs_39[0] = ((long) memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0)); + long[] callResult_39 = instance.getMachine().call(135, callArgs_39); + long[] callArgs_40 = new long[3]; + callArgs_40[2] = ((long) iL[7]); + callArgs_40[1] = ((long) ((int) callResult_39[0])); + callArgs_40[0] = ((long) (iL[2] + 320)); + long[] callResult_40 = instance.getMachine().call(155, callArgs_40); + } + long[] callArgs_41 = new long[3]; + callArgs_41[2] = ((long) (iL[2] + 320)); + callArgs_41[1] = ((long) iL[7]); + callArgs_41[0] = ((long) iL[9]); + long[] callResult_41 = instance.getMachine().call(350, callArgs_41); + iL[7] = ((int) callResult_41[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + long[] callArgs_42 = new long[1]; + callArgs_42[0] = ((long) (iL[2] + 320)); + long[] callResult_42 = instance.getMachine().call(162, callArgs_42); + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_43; + } + break; + } + iL[6] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break _hb; + } + iL[11] = (iL[0] + 12); + label_47: while (true) { + label_48: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(3, memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 32)) != 0) { + break label_48; + } + iL[8] = memory.readInt((int) (iL[6] + 48) < 0 ? (iL[6] + 48) : (iL[6] + 48) + 0); + long[] callArgs_43 = new long[2]; + callArgs_43[1] = ((long) (iL[6] + 52)); + callArgs_43[0] = ((long) (iL[2] + 280)); + long[] callResult_43 = instance.getMachine().call(159, callArgs_43); + iL[7] = ((int) callResult_43[0]); + iL[9] = ((int) memory.read((int) iL[6] < 0 ? iL[6] : iL[6] + 47) & 0xFF); + iL[1] = iL[9]; + iL[9] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[9]), 0); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 276, (int) (iL[9] != 0 ? memory.readInt((int) (iL[6] + 40) < 0 ? (iL[6] + 40) : (iL[6] + 40) + 0) : iL[1])); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 272, (int) (iL[9] != 0 ? memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 36) : (iL[6] + 36))); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 48, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 272)); + long[] callArgs_44 = new long[5]; + callArgs_44[4] = ((long) (iL[2] + 48)); + callArgs_44[3] = ((long) iL[7]); + callArgs_44[2] = ((long) iL[8]); + callArgs_44[1] = ((long) (iL[6] + 12)); + callArgs_44[0] = ((long) iL[11]); + long[] callResult_44 = instance.getMachine().call(352, callArgs_44); + iL[8] = ((int) callResult_44[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[8]))); + long[] callArgs_45 = new long[1]; + callArgs_45[0] = ((long) iL[7]); + long[] callResult_45 = instance.getMachine().call(162, callArgs_45); + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_47; + } + break; + } + iL[6] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break _hb; + } + iL[9] = (iL[0] + 12); + label_49: while (true) { + label_50: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(9, memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 32)) != 0) { + break label_50; + } + long[] callArgs_46 = new long[2]; + callArgs_46[1] = ((long) (iL[6] + 36)); + callArgs_46[0] = ((long) (iL[2] + 232)); + long[] callResult_46 = instance.getMachine().call(159, callArgs_46); + iL[7] = ((int) callResult_46[0]); + long[] callArgs_47 = new long[3]; + callArgs_47[2] = ((long) iL[7]); + callArgs_47[1] = ((long) (iL[6] + 12)); + callArgs_47[0] = ((long) iL[9]); + long[] callResult_47 = instance.getMachine().call(359, callArgs_47); + iL[8] = ((int) callResult_47[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[8]))); + long[] callArgs_48 = new long[1]; + callArgs_48[0] = ((long) iL[7]); + long[] callResult_48 = instance.getMachine().call(162, callArgs_48); + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_49; + } + break; + } + iL[9] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + break _hb; + } + iL[8] = (iL[0] + 12); + label_51: while (true) { + label_52: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(6, memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 32)) != 0) { + break label_52; + } + iL[6] = (iL[9] + 12); + iL[13] = (iL[9] + 52); + long[] callArgs_49 = new long[2]; + callArgs_49[1] = ((long) iL[13]); + callArgs_49[0] = ((long) (iL[2] + 192)); + long[] callResult_49 = instance.getMachine().call(159, callArgs_49); + iL[7] = ((int) callResult_49[0]); + long[] callArgs_50 = new long[4]; + callArgs_50[3] = ((long) memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 36)); + callArgs_50[2] = ((long) iL[7]); + callArgs_50[1] = ((long) iL[6]); + callArgs_50[0] = ((long) iL[8]); + long[] callResult_50 = instance.getMachine().call(360, callArgs_50); + iL[11] = ((int) callResult_50[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[11]))); + long[] callArgs_51 = new long[1]; + callArgs_51[0] = ((long) iL[7]); + long[] callResult_51 = instance.getMachine().call(162, callArgs_51); + lL[0] = memory.readLong((int) (iL[9] + 88) < 0 ? (iL[9] + 88) : (iL[9] + 88) + 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 184, (long) lL[0]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 40, (long) lL[0]); + long[] callArgs_52 = new long[3]; + callArgs_52[2] = ((long) (iL[2] + 40)); + callArgs_52[1] = ((long) iL[6]); + callArgs_52[0] = ((long) iL[8]); + long[] callResult_52 = instance.getMachine().call(361, callArgs_52); + iL[7] = ((int) callResult_52[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + label_53: { + if (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 36) != 0) { + break label_53; + } + lL[0] = 4294967295L; + label_54: { + long[] callArgs_53 = new long[2]; + callArgs_53[1] = ((long) iL[13]); + callArgs_53[0] = ((long) iL[3]); + long[] callResult_53 = instance.getMachine().call(123, callArgs_53); + iL[7] = ((int) callResult_53[0]); + iL[11] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 136); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[7], ((memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 140) - iL[11]) >> 2)) != 0) { + break label_54; + } + lL[0] = (((int) memory.read((int) (memory.readInt((int) (iL[11] + (iL[7] << 2)) < 0 ? (iL[11] + (iL[7] << 2)) : (iL[11] + (iL[7] << 2)) + 0) + 34) < 0 ? (memory.readInt((int) (iL[11] + (iL[7] << 2)) < 0 ? (iL[11] + (iL[7] << 2)) : (iL[11] + (iL[7] << 2)) + 0) + 34) : (memory.readInt((int) (iL[11] + (iL[7] << 2)) < 0 ? (iL[11] + (iL[7] << 2)) : (iL[11] + (iL[7] << 2)) + 0) + 34) + 0) & 0xFF) != 0 ? 4294967294L : 4294967295L); + } + lL[0] = (lL[0] | -4294967296L); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 32, (long) lL[0]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 176, (long) lL[0]); + long[] callArgs_54 = new long[3]; + callArgs_54[2] = ((long) (iL[2] + 32)); + callArgs_54[1] = ((long) iL[6]); + callArgs_54[0] = ((long) iL[8]); + long[] callResult_54 = instance.getMachine().call(368, callArgs_54); + iL[6] = ((int) callResult_54[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[6]))); + long[] callArgs_55 = new long[2]; + callArgs_55[1] = ((long) iL[0]); + callArgs_55[0] = ((long) (iL[2] + 360)); + long[] callResult_55 = instance.getMachine().call(447, callArgs_55); + long[] callArgs_56 = new long[2]; + callArgs_56[1] = ((long) (iL[9] + 96)); + callArgs_56[0] = ((long) ((int) callResult_55[0])); + long[] callResult_56 = instance.getMachine().call(453, callArgs_56); + iL[6] = ((int) callResult_56[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[6]))); + long[] callArgs_57 = new long[1]; + callArgs_57[0] = ((long) iL[8]); + long[] callResult_57 = instance.getMachine().call(369, callArgs_57); + iL[6] = ((int) callResult_57[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[6]))); + label_55: { + iL[6] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 400); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_55; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 404, (int) iL[6]); + long[] callArgs_58 = new long[1]; + callArgs_58[0] = ((long) iL[6]); + instance.getMachine().call(1777, callArgs_58); + } + label_56: { + iL[6] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 388); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_56; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 392, (int) iL[6]); + long[] callArgs_59 = new long[1]; + callArgs_59[0] = ((long) iL[6]); + instance.getMachine().call(1777, callArgs_59); + } + label_57: { + iL[6] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 376); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_57; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 380, (int) iL[6]); + long[] callArgs_60 = new long[1]; + callArgs_60[0] = ((long) iL[6]); + instance.getMachine().call(1777, callArgs_60); + } + iL[6] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 364); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_53; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 368, (int) iL[6]); + long[] callArgs_61 = new long[1]; + callArgs_61[0] = ((long) iL[6]); + instance.getMachine().call(1777, callArgs_61); + } + iL[6] = memory.readInt((int) (iL[9] + 108) < 0 ? (iL[9] + 108) : (iL[9] + 108) + 0); + iL[11] = memory.readInt((int) (iL[9] + 112) < 0 ? (iL[9] + 112) : (iL[9] + 112) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[11], iL[6]) != 0) { + break label_52; + } + label_58: while (true) { + iL[7] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0); + lL[0] = memory.readLong((int) iL[9] < 0 ? iL[9] : iL[9] + 88); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 168, (long) lL[0]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 24, (long) lL[0]); + long[] callArgs_62 = new long[3]; + callArgs_62[2] = ((long) (iL[2] + 24)); + callArgs_62[1] = ((long) (iL[7] + 12)); + callArgs_62[0] = ((long) iL[8]); + long[] callResult_62 = instance.getMachine().call(368, callArgs_62); + iL[7] = ((int) callResult_62[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + long[] callArgs_63 = new long[2]; + callArgs_63[1] = ((long) iL[0]); + callArgs_63[0] = ((long) (iL[2] + 360)); + long[] callResult_63 = instance.getMachine().call(447, callArgs_63); + long[] callArgs_64 = new long[2]; + callArgs_64[1] = ((long) iL[6]); + callArgs_64[0] = ((long) ((int) callResult_63[0])); + long[] callResult_64 = instance.getMachine().call(453, callArgs_64); + iL[7] = ((int) callResult_64[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + long[] callArgs_65 = new long[1]; + callArgs_65[0] = ((long) iL[8]); + long[] callResult_65 = instance.getMachine().call(369, callArgs_65); + iL[7] = ((int) callResult_65[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 300, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 300)) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]))); + label_59: { + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 400); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[7]) != 0) { + break label_59; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 404, (int) iL[7]); + long[] callArgs_66 = new long[1]; + callArgs_66[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_66); + } + label_60: { + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 388); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[7]) != 0) { + break label_60; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 392, (int) iL[7]); + long[] callArgs_67 = new long[1]; + callArgs_67[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_67); + } + label_61: { + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 376); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[7]) != 0) { + break label_61; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 380, (int) iL[7]); + long[] callArgs_68 = new long[1]; + callArgs_68[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_68); + } + label_62: { + iL[7] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 364); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[7]) != 0) { + break label_62; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 368, (int) iL[7]); + long[] callArgs_69 = new long[1]; + callArgs_69[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_69); + } + iL[6] = (iL[6] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[11], iL[6]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_58; + } + break; + } + } + iL[9] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 4); + if (iL[9] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_51; + } + break; + } + } while (false); + return _hs[0]; + } + + private static int func_557__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_11: { + label_12: { + label_13: { + label_14: { + label_15: { + label_16: { + label_17: { + label_18: { + int _d1 = func_557__h1(iL, memory, instance); + if (_d1 == 1) + break label_12; + if (_d1 == 2) + break label_17; + if (_d1 == 3) + break label_16; + if (_d1 == 4) + break label_15; + if (_d1 == 5) + break label_14; + if (_d1 == 6) + break label_13; + if (_d1 == 7) + break label_11; + if (_d1 >= 10000) { + _hs[0] = (_d1 - 10000); + break _hb; + } + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 59); + callArgs_6[1] = ((long) iL[1]); + callArgs_6[0] = ((long) iL[0]); + instance.getMachine().call(561, callArgs_6); + { + _hs[0] = 3; + break _hb; + } + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) iL[1]); + callArgs_7[0] = ((long) iL[0]); + instance.getMachine().call(563, callArgs_7); + { + _hs[0] = 3; + break _hb; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 260, (int) 6); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 256, (int) 27527); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 216, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 256)); + long[] callArgs_8 = new long[4]; + callArgs_8[3] = ((long) 131); + callArgs_8[2] = ((long) (iL[3] + 216)); + callArgs_8[1] = ((long) iL[1]); + callArgs_8[0] = ((long) iL[0]); + instance.getMachine().call(564, callArgs_8); + { + _hs[0] = 3; + break _hb; + } + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) iL[1]); + callArgs_9[0] = ((long) iL[0]); + instance.getMachine().call(559, callArgs_9); + { + _hs[0] = 3; + break _hb; + } + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) iL[1]); + callArgs_10[0] = ((long) iL[0]); + instance.getMachine().call(560, callArgs_10); + { + _hs[0] = 3; + break _hb; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 252, (int) 7); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 248, (int) 27519); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 56, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 248)); + long[] callArgs_11 = new long[4]; + callArgs_11[3] = ((long) 133); + callArgs_11[2] = ((long) (iL[3] + 56)); + callArgs_11[1] = ((long) iL[1]); + callArgs_11[0] = ((long) iL[0]); + instance.getMachine().call(564, callArgs_11); + { + _hs[0] = 3; + break _hb; + } + } + label_35: { + iL[5] = ((int) memory.read((int) (iL[8] + 43169) < 0 ? (iL[8] + 43169) : (iL[8] + 43169) + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[5] & 2)) != 0) { + break label_35; + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) iL[1]); + callArgs_12[0] = ((long) iL[0]); + instance.getMachine().call(565, callArgs_12); + { + _hs[0] = 3; + break _hb; + } + } + label_36: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[5] & 1)) != 0) { + break label_36; + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) iL[1]); + callArgs_13[0] = ((long) iL[0]); + instance.getMachine().call(562, callArgs_13); + { + _hs[0] = 3; + break _hb; + } + } + iL[5] = (iL[4] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[5]); + iL[8] = ((iL[3] + 224) + 8); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[9] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0); + iL[5] = (iL[5] - iL[9]); + iL[10] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[5], 0) != 0 ? iL[5] : 0) + 1); + memory.writeI32((int) ((iL[3] + 224) + 16) < 0 ? ((iL[3] + 224) + 16) : ((iL[3] + 224) + 16) + 0, (int) iL[10]); + iL[11] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[12] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[5] = (int) (byte) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15); + memory.writeI32((int) ((iL[3] + 32) + 16) < 0 ? ((iL[3] + 32) + 16) : ((iL[3] + 32) + 16) + 0, (int) iL[10]); + iL[4] = (iL[4] - iL[9]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 236, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1)); + memory.writeLong((int) ((iL[3] + 32) + 8) < 0 ? ((iL[3] + 32) + 8) : ((iL[3] + 32) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + iL[4] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[5], 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 228, (int) (iL[4] != 0 ? iL[12] : (iL[5] & 255))); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 224, (int) (iL[4] != 0 ? iL[11] : iL[6])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 32, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 224)); + long[] callArgs_14 = new long[4]; + callArgs_14[3] = ((long) 0); + callArgs_14[2] = ((long) 11782); + callArgs_14[1] = ((long) (iL[3] + 32)); + callArgs_14[0] = ((long) iL[1]); + instance.getMachine().call(566, callArgs_14); + { + _hs[0] = 6; + break _hb; + } + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) (iL[4] + 2)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(120, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 1) & 0xFF)) != 0) { + break _hb; + } + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) 59); + callArgs_15[1] = ((long) iL[1]); + callArgs_15[0] = ((long) iL[0]); + instance.getMachine().call(567, callArgs_15); + { + _hs[0] = 3; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_558__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_9: { + label_10: { + iL[11] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(10, iL[11]) != 0) { + break label_10; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(92, iL[11]) != 0) { + break label_9; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, iL[11]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[10], iL[6]) != 0) { + break _hb; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(34, ((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 0) & 0xFF)) != 0) { + break _hb; + } + iL[11] = ((iL[3] + 224) + 8); + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[6] = memory.readInt((int) (iL[1] + 28) < 0 ? (iL[1] + 28) : (iL[1] + 28) + 0); + iL[4] = (iL[10] - iL[6]); + iL[10] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1); + memory.writeI32((int) ((iL[3] + 224) + 16) < 0 ? ((iL[3] + 224) + 16) : ((iL[3] + 224) + 16) + 0, (int) iL[10]); + iL[8] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[12] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[4] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + iL[13] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 32); + memory.writeI32((int) ((iL[3] + 120) + 16) < 0 ? ((iL[3] + 120) + 16) : ((iL[3] + 120) + 16) + 0, (int) iL[10]); + iL[10] = (iL[13] - iL[6]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 236, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[10], 0) != 0 ? iL[10] : 0) + 1)); + memory.writeLong((int) ((iL[3] + 120) + 8) < 0 ? ((iL[3] + 120) + 8) : ((iL[3] + 120) + 8) + 0, (long) memory.readLong((int) iL[11] < 0 ? iL[11] : iL[11] + 0)); + iL[10] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[4]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 228, (int) (iL[10] != 0 ? iL[12] : iL[4])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 224, (int) (iL[10] != 0 ? iL[8] : iL[5])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 120, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 224)); + long[] callArgs_0 = new long[4]; + callArgs_0[3] = ((long) 0); + callArgs_0[2] = ((long) 12960); + callArgs_0[1] = ((long) (iL[3] + 120)); + callArgs_0[0] = ((long) iL[1]); + instance.getMachine().call(566, callArgs_0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 32, (int) iL[7]); + { + _hs[0] = 2; + break _hb; + } + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 32, (int) iL[4]); + iL[11] = ((iL[3] + 248) + 8); + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[9] = 1; + iL[6] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[10] = (iL[10] - iL[6]); + iL[12] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[10], 0) != 0 ? iL[10] : 0) + 1); + memory.writeI32((int) ((iL[3] + 248) + 16) < 0 ? ((iL[3] + 248) + 16) : ((iL[3] + 248) + 16) + 0, (int) iL[12]); + iL[13] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[14] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[10] = (int) (byte) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15); + memory.writeI32((int) ((iL[3] + 72) + 16) < 0 ? ((iL[3] + 72) + 16) : ((iL[3] + 72) + 16) + 0, (int) iL[12]); + iL[4] = (iL[4] - iL[6]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 260, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1)); + memory.writeLong((int) ((iL[3] + 72) + 8) < 0 ? ((iL[3] + 72) + 8) : ((iL[3] + 72) + 8) + 0, (long) memory.readLong((int) iL[11] < 0 ? iL[11] : iL[11] + 0)); + iL[4] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[10], 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 252, (int) (iL[4] != 0 ? iL[14] : (iL[10] & 255))); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 248, (int) (iL[4] != 0 ? iL[13] : iL[5])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 72, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 248)); + long[] callArgs_1 = new long[4]; + callArgs_1[3] = ((long) 0); + callArgs_1[2] = ((long) 14343); + callArgs_1[1] = ((long) (iL[3] + 72)); + callArgs_1[0] = ((long) iL[1]); + instance.getMachine().call(566, callArgs_1); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36)); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 16, (int) (memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16) + 1)); + { + _hs[0] = 1; + break _hb; + } + } + label_11: { + label_12: { + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[10], iL[6]) != 0) { + break label_13; + } + iL[10] = (iL[4] + 2); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[10]); + label_14: { + label_15: { + switch((((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 1) & 0xFF) + -34)) { + case 0: + { + { + _hs[0] = 1; + break _hb; + } + } + case 1: + { + break label_13; + } + case 2: + { + break label_13; + } + case 3: + { + break label_13; + } + case 4: + { + break label_13; + } + case 5: + { + { + _hs[0] = 1; + break _hb; + } + } + case 6: + { + break label_13; + } + case 7: + { + break label_13; + } + case 8: + { + break label_13; + } + case 9: + { + break label_13; + } + case 10: + { + break label_13; + } + case 11: + { + break label_13; + } + case 12: + { + break label_13; + } + case 13: + { + break label_13; + } + case 14: + { + break label_15; + } + case 15: + { + break label_15; + } + case 16: + { + break label_15; + } + case 17: + { + break label_15; + } + case 18: + { + break label_15; + } + case 19: + { + break label_15; + } + case 20: + { + break label_15; + } + case 21: + { + break label_15; + } + case 22: + { + break label_15; + } + case 23: + { + break label_15; + } + case 24: + { + break label_13; + } + case 25: + { + break label_13; + } + case 26: + { + break label_13; + } + case 27: + { + break label_13; + } + case 28: + { + break label_13; + } + case 29: + { + break label_13; + } + case 30: + { + break label_13; + } + case 31: + { + break label_15; + } + case 32: + { + break label_15; + } + case 33: + { + break label_15; + } + case 34: + { + break label_15; + } + case 35: + { + break label_15; + } + case 36: + { + break label_15; + } + case 37: + { + break label_13; + } + case 38: + { + break label_13; + } + case 39: + { + break label_13; + } + case 40: + { + break label_13; + } + case 41: + { + break label_13; + } + case 42: + { + break label_13; + } + case 43: + { + break label_13; + } + case 44: + { + break label_13; + } + case 45: + { + break label_13; + } + case 46: + { + break label_13; + } + case 47: + { + break label_13; + } + case 48: + { + break label_13; + } + case 49: + { + break label_13; + } + case 50: + { + break label_13; + } + case 51: + { + break label_13; + } + case 52: + { + break label_13; + } + case 53: + { + break label_13; + } + case 54: + { + break label_13; + } + case 55: + { + break label_13; + } + case 56: + { + break label_13; + } + case 57: + { + break label_13; + } + case 58: + { + { + _hs[0] = 1; + break _hb; + } + } + case 59: + { + break label_13; + } + case 60: + { + break label_13; + } + case 61: + { + break label_13; + } + case 62: + { + break label_13; + } + case 63: + { + break label_15; + } + case 64: + { + break label_15; + } + case 65: + { + break label_15; + } + case 66: + { + break label_15; + } + case 67: + { + break label_15; + } + case 68: + { + break label_15; + } + case 69: + { + break label_13; + } + case 70: + { + break label_13; + } + case 71: + { + break label_13; + } + case 72: + { + break label_13; + } + case 73: + { + break label_13; + } + case 74: + { + break label_13; + } + case 75: + { + break label_13; + } + case 76: + { + { + _hs[0] = 1; + break _hb; + } + } + case 77: + { + break label_13; + } + case 78: + { + break label_13; + } + case 79: + { + break label_13; + } + case 80: + { + { + _hs[0] = 1; + break _hb; + } + } + case 81: + { + break label_13; + } + case 82: + { + { + _hs[0] = 1; + break _hb; + } + } + case 83: + { + break label_14; + } + default: + { + break label_13; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[10], iL[6]) != 0) { + break label_12; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 0) & 0xFF) + 43169) < 0 ? (((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 0) & 0xFF) + 43169) : (((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 0) & 0xFF) + 43169) + 0) & 0xFF) & 4)) != 0) { + break label_12; + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) (iL[4] + 3)); + { + _hs[0] = 1; + break _hb; + } + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 32, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[10], iL[6]) != 0) { + break label_11; + } + iL[10] = (iL[4] + 3); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[10]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(123, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 2) & 0xFF)) != 0) { + break label_11; + } + iL[4] = 0; + label_16: { + label_17: { + label_18: while (true) { + iL[10] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[10], memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 24)) != 0) { + break label_16; + } + iL[11] = ((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (iL[11] + 43169) < 0 ? (iL[11] + 43169) : (iL[11] + 43169) + 0) & 0xFF) & 4)) != 0) { + break label_17; + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) (iL[10] + 1)); + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (iL[3] + 280)); + callArgs_2[0] = ((long) (int) (byte) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 0)); + long[] callResult_2 = instance.getMachine().call(546, callArgs_2); + iL[4] = (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 280) | (iL[4] << 4)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[4], 1114112) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break; + } + iL[10] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 36); + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 32); + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(125, iL[11]) != 0) { + break label_16; + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(55296, (iL[4] & 2095104)) != 0) { + break label_19; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE((iL[10] + -3), memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 32)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + } + iL[10] = (iL[10] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[10]); + } + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 32); + break label_11; + } + iL[4] = (iL[10] + -2); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 32, (int) iL[4]); + } + iL[6] = ((iL[3] + 200) + 8); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[9] = 1; + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[11] = (iL[10] - iL[12]); + iL[13] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[11], 0) != 0 ? iL[11] : 0) + 1); + memory.writeI32((int) ((iL[3] + 200) + 16) < 0 ? ((iL[3] + 200) + 16) : ((iL[3] + 200) + 16) + 0, (int) iL[13]); + iL[14] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[15] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[11] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + memory.writeI32((int) ((iL[3] + 48) + 16) < 0 ? ((iL[3] + 48) + 16) : ((iL[3] + 48) + 16) + 0, (int) iL[13]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (int) iL[4]); + iL[12] = (iL[4] - iL[12]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 212, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[12], 0) != 0 ? iL[12] : 0) + 1)); + memory.writeLong((int) ((iL[3] + 48) + 8) < 0 ? ((iL[3] + 48) + 8) : ((iL[3] + 48) + 8) + 0, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + iL[6] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[11]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 204, (int) (iL[6] != 0 ? iL[15] : iL[11])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 200, (int) (iL[6] != 0 ? iL[14] : iL[5])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 32, (int) (iL[10] - iL[4])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 48, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 200)); + long[] callArgs_3 = new long[4]; + callArgs_3[3] = ((long) (iL[3] + 32)); + callArgs_3[2] = ((long) 30822); + callArgs_3[1] = ((long) (iL[3] + 48)); + callArgs_3[0] = ((long) iL[1]); + instance.getMachine().call(566, callArgs_3); + { + _hs[0] = 1; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_570__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[4] = (iL[1] + -2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[4], 33) != 0) { + break _hb; + } + iL[5] = iL[1]; + iL[6] = iL[1]; + iL[7] = iL[1]; + iL[8] = iL[1]; + iL[9] = iL[1]; + iL[10] = iL[1]; + iL[11] = iL[1]; + iL[12] = iL[1]; + iL[13] = iL[1]; + iL[14] = iL[1]; + iL[15] = iL[1]; + iL[16] = iL[1]; + iL[3] = iL[1]; + label_3: { + label_4: { + label_5: { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + label_13: { + label_14: { + label_15: { + label_16: { + switch(iL[4]) { + case 0: + { + break label_3; + } + case 1: + { + break label_4; + } + case 2: + { + break label_4; + } + case 3: + { + break label_5; + } + case 4: + { + break label_6; + } + case 5: + { + break label_7; + } + case 6: + { + break label_8; + } + case 7: + { + break label_8; + } + case 8: + { + break label_9; + } + case 9: + { + break label_9; + } + case 10: + { + break label_10; + } + case 11: + { + break label_10; + } + case 12: + { + break label_10; + } + case 13: + { + break label_11; + } + case 14: + { + break label_11; + } + case 15: + { + break label_12; + } + case 16: + { + break label_13; + } + case 17: + { + break label_14; + } + case 18: + { + break label_14; + } + case 19: + { + break label_14; + } + case 20: + { + break label_14; + } + case 21: + { + break label_15; + } + case 22: + { + break label_15; + } + case 23: + { + break label_15; + } + case 24: + { + break label_15; + } + default: + { + break label_16; + } + } + } + iL[5] = (((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 26) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 26) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 26) & 0xFF) << 1) + 43440) + 0) & 0xFFFF) + iL[1]); + } + iL[6] = (iL[5] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 22) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 22) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 22) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[7] = (iL[6] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 18) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 18) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 18) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[8] = (iL[7] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 17) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 17) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 17) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[9] = (iL[8] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 16) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 16) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 16) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[10] = (iL[9] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 14) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 14) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 14) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[11] = (iL[10] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 11) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 11) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 11) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[12] = (iL[11] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 9) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 9) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 9) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[13] = (iL[12] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 7) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 7) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 7) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[14] = (iL[13] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 6) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 6) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 6) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[15] = (iL[14] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 5) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 5) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 5) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[16] = (iL[15] + ((int) memory.readShort((int) ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 4) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 4) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 4) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + } + iL[3] = (iL[16] + ((int) memory.readShort((int) ((((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 2) & 0xFF) + 1) & 255) << 1) + 43440) < 0 ? ((((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 2) & 0xFF) + 1) & 255) << 1) + 43440) : ((((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 2) & 0xFF) + 1) & 255) << 1) + 43440) + 0) & 0xFFFF)); + } + label_17: { + iL[4] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF); + iL[16] = (iL[1] + -1); + iL[3] = ((iL[3] + ((int) memory.readShort((int) ((((iL[4] + 1) & 255) << 1) + 43440) < 0 ? ((((iL[4] + 1) & 255) << 1) + 43440) : ((((iL[4] + 1) & 255) << 1) + 43440) + 0) & 0xFFFF)) + ((int) memory.readShort((int) ((((int) memory.read((int) (iL[0] + iL[16]) < 0 ? (iL[0] + iL[16]) : (iL[0] + iL[16]) + 0) & 0xFF) << 1) + 43440) < 0 ? ((((int) memory.read((int) (iL[0] + iL[16]) < 0 ? (iL[0] + iL[16]) : (iL[0] + iL[16]) + 0) & 0xFF) << 1) + 43440) : ((((int) memory.read((int) (iL[0] + iL[16]) < 0 ? (iL[0] + iL[16]) : (iL[0] + iL[16]) + 0) & 0xFF) << 1) + 43440) + 0) & 0xFFFF)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[3], 2229) != 0) { + break label_17; + } + iL[3] = ((iL[3] << 4) + 622000); + iL[2] = iL[4]; + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF), (iL[2] & 255)) != 0) { + break label_17; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) iL[16]); + callArgs_0[1] = ((long) (iL[4] + 1)); + callArgs_0[0] = ((long) (iL[0] + 1)); + long[] callResult_0 = instance.getMachine().call(1898, callArgs_0); + if (((int) callResult_0[0]) != 0) { + break label_17; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) (iL[4] + iL[1]) < 0 ? (iL[4] + iL[1]) : (iL[4] + iL[1]) + 0) & 0xFF)) != 0) { + break _hb; + } + } + iL[3] = 0; + } while (false); + return _hs[0]; + } + + private static int func_801__h0(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_42: { + int _d3 = func_801__h3(iL, lL, memory, instance); + if (_d3 >= 10000) { + _hs[0] = (_d3 - 10000); + break _hb; + } + } + iL[3] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[17], 5) != 0 ? iL[17] : 5); + iL[15] = (iL[18] + iL[3]); + label_419: { + label_420: { + if (iL[3] != 0) { + break label_420; + } + iL[16] = iL[18]; + break label_419; + } + iL[3] = iL[18]; + iL[16] = iL[15]; + label_421: while (true) { + iL[13] = iL[3]; + label_422: while (true) { + iL[3] = (iL[13] + 1); + label_423: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(114, ((int) memory.read((int) iL[13] < 0 ? iL[13] : iL[13] + 0) & 0xFF)) != 0) { + break label_423; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[15], iL[3]) != 0) { + break label_419; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(101, ((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_421; + } + iL[20] = (iL[13] + 2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[15], iL[20]) != 0) { + break label_419; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(108, ((int) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_421; + } + iL[20] = (iL[13] + 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[15], iL[20]) != 0) { + break label_419; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(111, ((int) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_421; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[15], (iL[13] + 4)) != 0) { + break label_419; + } + iL[3] = (iL[13] + 1); + iL[16] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(99, ((int) memory.read((int) iL[13] < 0 ? iL[13] : iL[13] + 4) & 0xFF)) != 0 ? iL[13] : iL[16]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_421; + } + iL[13] = iL[3]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[15], iL[3]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_422; + } + break; + } + break; + } + } + label_424: { + label_425: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[15], iL[16]) != 0) { + break label_425; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[18], iL[16]) != 0) { + break label_425; + } + label_426: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_456 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 724)); + int ciFuncId_456 = instance.table(0).requiredRef(ciTableIdx_456); + com.dylibso.chicory.runtime.Instance ciRefInstance_456 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_456), instance); + if (!ciRefInstance_456.type(ciRefInstance_456.functionType(ciFuncId_456)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_456 = new long[2]; + callArgs_456[1] = ((long) iL[0]); + callArgs_456[0] = ((long) iL[3]); + long[] callResult_456 = ciRefInstance_456.getMachine().call(ciFuncId_456, callArgs_456); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_456[0])) != 0) { + break label_426; + } + long[] callArgs_457 = new long[3]; + callArgs_457[2] = ((long) 0); + callArgs_457[1] = ((long) 24505); + callArgs_457[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_457); + { + _hs[0] = 2; + break _hb; + } + } + label_427: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_458 = new long[3]; + callArgs_458[2] = ((long) (iL[4] + 3256)); + callArgs_458[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_458[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_458 = instance.getMachine().call(177, callArgs_458); + iL[0] = ((int) callResult_458[0]); + if (iL[0] != 0) { + break label_427; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 480, (int) 1585); + long[] callArgs_459 = new long[3]; + callArgs_459[2] = ((long) (iL[4] + 480)); + callArgs_459[1] = ((long) 11260); + callArgs_459[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_459); + { + _hs[0] = 2; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_428: { + long[] callArgs_460 = new long[3]; + callArgs_460[2] = ((long) (iL[4] + 3168)); + callArgs_460[1] = ((long) (iL[3] + iL[13])); + callArgs_460[0] = ((long) (iL[3] + iL[0])); + long[] callResult_460 = instance.getMachine().call(177, callArgs_460); + iL[3] = ((int) callResult_460[0]); + if (iL[3] != 0) { + break label_428; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 496, (int) 6395); + long[] callArgs_461 = new long[3]; + callArgs_461[2] = ((long) (iL[4] + 496)); + callArgs_461[1] = ((long) 11260); + callArgs_461[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_461); + { + _hs[0] = 2; + break _hb; + } + } + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_429: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_429; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 520, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 516, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 512, (int) 6395); + long[] callArgs_462 = new long[3]; + callArgs_462[2] = ((long) (iL[4] + 512)); + callArgs_462[1] = ((long) 12552); + callArgs_462[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_462); + { + _hs[0] = 2; + break _hb; + } + } + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_463 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 728)); + int ciFuncId_463 = instance.table(0).requiredRef(ciTableIdx_463); + com.dylibso.chicory.runtime.Instance ciRefInstance_463 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_463), instance); + if (!ciRefInstance_463.type(ciRefInstance_463.functionType(ciFuncId_463)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_463 = new long[3]; + callArgs_463[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3256)); + callArgs_463[1] = ((long) iL[3]); + callArgs_463[0] = ((long) iL[0]); + long[] callResult_463 = ciRefInstance_463.getMachine().call(ciFuncId_463, callArgs_463); + if (((int) callResult_463[0]) != 0) { + break label_424; + } + label_430: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_430; + } + label_431: while (true) { + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3240, (int) 0); + label_432: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_464 = new long[3]; + callArgs_464[2] = ((long) (iL[4] + 3248)); + callArgs_464[1] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_464[0] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_464 = instance.getMachine().call(177, callArgs_464); + iL[13] = ((int) callResult_464[0]); + if (iL[13] != 0) { + break label_432; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 528, (int) 15863); + long[] callArgs_465 = new long[3]; + callArgs_465[2] = ((long) (iL[4] + 528)); + callArgs_465[1] = ((long) 11260); + callArgs_465[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_465); + { + _hs[0] = 2; + break _hb; + } + } + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_433: { + long[] callArgs_466 = new long[3]; + callArgs_466[2] = ((long) (iL[4] + 3168)); + callArgs_466[1] = ((long) (iL[0] + iL[15])); + callArgs_466[0] = ((long) (iL[0] + iL[13])); + long[] callResult_466 = instance.getMachine().call(177, callArgs_466); + iL[13] = ((int) callResult_466[0]); + if (iL[13] != 0) { + break label_433; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 544, (int) 7295); + long[] callArgs_467 = new long[3]; + callArgs_467[2] = ((long) (iL[4] + 544)); + callArgs_467[1] = ((long) 11260); + callArgs_467[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_467); + { + _hs[0] = 2; + break _hb; + } + } + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + label_434: { + long[] callArgs_468 = new long[3]; + callArgs_468[2] = ((long) (iL[4] + 3168)); + callArgs_468[1] = ((long) (iL[0] + iL[15])); + callArgs_468[0] = ((long) (iL[0] + iL[13])); + long[] callResult_468 = instance.getMachine().call(177, callArgs_468); + iL[0] = ((int) callResult_468[0]); + if (iL[0] != 0) { + break label_434; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 560, (int) 2231); + long[] callArgs_469 = new long[3]; + callArgs_469[2] = ((long) (iL[4] + 560)); + callArgs_469[1] = ((long) 11260); + callArgs_469[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_469); + { + _hs[0] = 2; + break _hb; + } + } + iL[15] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[15]); + label_435: { + label_436: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3248); + iL[13] = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[0], 26); + if (iL[13] != 0) { + break label_436; + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + label_437: { + label_438: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((1 << iL[0]) & 48483128)) != 0) { + break label_438; + } + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_470 = new long[3]; + callArgs_470[2] = ((long) (iL[4] + 3240)); + callArgs_470[1] = ((long) (iL[17] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_470[0] = ((long) (iL[17] + iL[15])); + long[] callResult_470 = instance.getMachine().call(179, callArgs_470); + iL[15] = ((int) callResult_470[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[15]) != 0) { + break label_437; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15])); + } + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_471 = (int) (memory.readInt((int) memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) < 0 ? memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) : memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) + 732)); + int ciFuncId_471 = instance.table(0).requiredRef(ciTableIdx_471); + com.dylibso.chicory.runtime.Instance ciRefInstance_471 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_471), instance); + if (!ciRefInstance_471.type(ciRefInstance_471.functionType(ciFuncId_471)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_471 = new long[5]; + callArgs_471[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3240)); + callArgs_471[3] = ((long) iL[13]); + callArgs_471[2] = ((long) iL[16]); + callArgs_471[1] = ((long) iL[0]); + callArgs_471[0] = ((long) iL[15]); + long[] callResult_471 = ciRefInstance_471.getMachine().call(ciFuncId_471, callArgs_471); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_471[0])) != 0) { + break label_435; + } + long[] callArgs_472 = new long[3]; + callArgs_472[2] = ((long) 0); + callArgs_472[1] = ((long) 25586); + callArgs_472[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_472); + { + _hs[0] = 2; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 592, (int) 17700); + long[] callArgs_473 = new long[3]; + callArgs_473[2] = ((long) (iL[4] + 592)); + callArgs_473[1] = ((long) 11290); + callArgs_473[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_473); + { + _hs[0] = 2; + break _hb; + } + } + iL[3] = 27457; + label_439: { + if (iL[13] != 0) { + break label_439; + } + iL[3] = memory.readInt((int) (62288 + (iL[0] << 2)) < 0 ? (62288 + (iL[0] << 2)) : (62288 + (iL[0] << 2)) + 0); + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 576, (int) iL[3]); + long[] callArgs_474 = new long[3]; + callArgs_474[2] = ((long) (iL[4] + 576)); + callArgs_474[1] = ((long) 11021); + callArgs_474[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_474); + { + _hs[0] = 2; + break _hb; + } + } + iL[3] = (iL[3] + -1); + if (iL[3] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_431; + } + break; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_475 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 736)); + int ciFuncId_475 = instance.table(0).requiredRef(ciTableIdx_475); + com.dylibso.chicory.runtime.Instance ciRefInstance_475 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_475), instance); + if (!ciRefInstance_475.type(ciRefInstance_475.functionType(ciFuncId_475)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_475 = new long[1]; + callArgs_475[0] = ((long) iL[3]); + long[] callResult_475 = ciRefInstance_475.getMachine().call(ciFuncId_475, callArgs_475); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_475[0])) != 0) { + { + _hs[0] = 4; + break _hb; + } + } + long[] callArgs_476 = new long[3]; + callArgs_476[2] = ((long) 0); + callArgs_476[1] = ((long) 24539); + callArgs_476[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_476); + { + _hs[0] = 2; + break _hb; + } + } + label_440: { + int _d10 = func_801__h10(iL, lL, memory, instance); + if (_d10 >= 10000) { + _hs[0] = (_d10 - 10000); + break _hb; + } + } + long[] callArgs_574 = new long[3]; + callArgs_574[2] = ((long) 0); + callArgs_574[1] = ((long) 19903); + callArgs_574[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_574); + { + _hs[0] = 2; + break _hb; + } + } + long[] callArgs_575 = new long[3]; + callArgs_575[2] = ((long) 0); + callArgs_575[1] = ((long) 20055); + callArgs_575[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_575); + { + _hs[0] = 2; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h0(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_62: { + label_63: { + label_64: { + label_65: { + label_66: { + int _d6 = func_804__h6(iL, lL, memory, instance); + if (_d6 == 1) + break label_65; + if (_d6 == 2) + break label_64; + if (_d6 == 3) + break label_63; + if (_d6 == 4) + break label_62; + if (_d6 >= 10000) { + _hs[0] = (_d6 - 10000); + break _hb; + } + } + long[] callArgs_299 = new long[3]; + callArgs_299[2] = ((long) 0); + callArgs_299[1] = ((long) 28714); + callArgs_299[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_299); + iL[11] = 1; + { + _hs[0] = 7; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_300 = new long[3]; + callArgs_300[2] = ((long) 2109); + callArgs_300[1] = ((long) (iL[3] + 352)); + callArgs_300[0] = ((long) iL[0]); + long[] callResult_300 = instance.getMachine().call(814, callArgs_300); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_300[0])) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + long[] callArgs_301 = new long[3]; + callArgs_301[2] = ((long) 26416); + callArgs_301[1] = ((long) (iL[3] + 336)); + callArgs_301[0] = ((long) iL[0]); + long[] callResult_301 = instance.getMachine().call(814, callArgs_301); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_301[0])) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + label_261: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + iL[10] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + int ciTableIdx_302 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 448)); + int ciFuncId_302 = instance.table(0).requiredRef(ciTableIdx_302); + com.dylibso.chicory.runtime.Instance ciRefInstance_302 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_302), instance); + if (!ciRefInstance_302.type(ciRefInstance_302.functionType(ciFuncId_302)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_302 = new long[3]; + callArgs_302[2] = ((long) iL[10]); + callArgs_302[1] = ((long) iL[12]); + callArgs_302[0] = ((long) iL[4]); + long[] callResult_302 = ciRefInstance_302.getMachine().call(ciFuncId_302, callArgs_302); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_302[0])) != 0) { + break label_261; + } + iL[4] = 20492; + { + _hs[0] = 45; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_303 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 244)); + int ciFuncId_303 = instance.table(0).requiredRef(ciTableIdx_303); + com.dylibso.chicory.runtime.Instance ciRefInstance_303 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_303), instance); + if (!ciRefInstance_303.type(ciRefInstance_303.functionType(ciFuncId_303)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_303 = new long[3]; + callArgs_303[2] = ((long) iL[10]); + callArgs_303[1] = ((long) iL[12]); + callArgs_303[0] = ((long) iL[4]); + long[] callResult_303 = ciRefInstance_303.getMachine().call(ciFuncId_303, callArgs_303); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_303[0])) != 0) { + { + _hs[0] = 8; + break _hb; + } + } + iL[4] = 25823; + { + _hs[0] = 45; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_304 = new long[3]; + callArgs_304[2] = ((long) 2118); + callArgs_304[1] = ((long) (iL[3] + 352)); + callArgs_304[0] = ((long) iL[0]); + long[] callResult_304 = instance.getMachine().call(814, callArgs_304); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_304[0])) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + label_262: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_305 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 460)); + int ciFuncId_305 = instance.table(0).requiredRef(ciTableIdx_305); + com.dylibso.chicory.runtime.Instance ciRefInstance_305 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_305), instance); + if (!ciRefInstance_305.type(ciRefInstance_305.functionType(ciFuncId_305)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_305 = new long[2]; + callArgs_305[1] = ((long) iL[12]); + callArgs_305[0] = ((long) iL[4]); + long[] callResult_305 = ciRefInstance_305.getMachine().call(ciFuncId_305, callArgs_305); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_305[0])) != 0) { + break label_262; + } + iL[4] = 21385; + { + _hs[0] = 46; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_306 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 232)); + int ciFuncId_306 = instance.table(0).requiredRef(ciTableIdx_306); + com.dylibso.chicory.runtime.Instance ciRefInstance_306 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_306), instance); + if (!ciRefInstance_306.type(ciRefInstance_306.functionType(ciFuncId_306)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_306 = new long[2]; + callArgs_306[1] = ((long) iL[12]); + callArgs_306[0] = ((long) iL[4]); + long[] callResult_306 = ciRefInstance_306.getMachine().call(ciFuncId_306, callArgs_306); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_306[0])) != 0) { + { + _hs[0] = 8; + break _hb; + } + } + iL[4] = 25792; + { + _hs[0] = 46; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_307 = new long[3]; + callArgs_307[2] = ((long) 2118); + callArgs_307[1] = ((long) (iL[3] + 352)); + callArgs_307[0] = ((long) iL[0]); + long[] callResult_307 = instance.getMachine().call(814, callArgs_307); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_307[0])) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + label_263: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_308 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 464)); + int ciFuncId_308 = instance.table(0).requiredRef(ciTableIdx_308); + com.dylibso.chicory.runtime.Instance ciRefInstance_308 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_308), instance); + if (!ciRefInstance_308.type(ciRefInstance_308.functionType(ciFuncId_308)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_308 = new long[2]; + callArgs_308[1] = ((long) iL[12]); + callArgs_308[0] = ((long) iL[4]); + long[] callResult_308 = ciRefInstance_308.getMachine().call(ciFuncId_308, callArgs_308); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_308[0])) != 0) { + break label_263; + } + iL[4] = 21291; + { + _hs[0] = 47; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_309 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 232)); + int ciFuncId_309 = instance.table(0).requiredRef(ciTableIdx_309); + com.dylibso.chicory.runtime.Instance ciRefInstance_309 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_309), instance); + if (!ciRefInstance_309.type(ciRefInstance_309.functionType(ciFuncId_309)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_309 = new long[2]; + callArgs_309[1] = ((long) iL[12]); + callArgs_309[0] = ((long) iL[4]); + long[] callResult_309 = ciRefInstance_309.getMachine().call(ciFuncId_309, callArgs_309); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_309[0])) != 0) { + { + _hs[0] = 8; + break _hb; + } + } + iL[4] = 25792; + { + _hs[0] = 47; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_310 = new long[3]; + callArgs_310[2] = ((long) 2118); + callArgs_310[1] = ((long) (iL[3] + 352)); + callArgs_310[0] = ((long) iL[0]); + long[] callResult_310 = instance.getMachine().call(814, callArgs_310); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_310[0])) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + label_264: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_311 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 468)); + int ciFuncId_311 = instance.table(0).requiredRef(ciTableIdx_311); + com.dylibso.chicory.runtime.Instance ciRefInstance_311 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_311), instance); + if (!ciRefInstance_311.type(ciRefInstance_311.functionType(ciFuncId_311)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_311 = new long[2]; + callArgs_311[1] = ((long) iL[12]); + callArgs_311[0] = ((long) iL[4]); + long[] callResult_311 = ciRefInstance_311.getMachine().call(ciFuncId_311, callArgs_311); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_311[0])) != 0) { + break label_264; + } + iL[4] = 20650; + { + _hs[0] = 48; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_312 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 232)); + int ciFuncId_312 = instance.table(0).requiredRef(ciTableIdx_312); + com.dylibso.chicory.runtime.Instance ciRefInstance_312 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_312), instance); + if (!ciRefInstance_312.type(ciRefInstance_312.functionType(ciFuncId_312)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_312 = new long[2]; + callArgs_312[1] = ((long) iL[12]); + callArgs_312[0] = ((long) iL[4]); + long[] callResult_312 = ciRefInstance_312.getMachine().call(ciFuncId_312, callArgs_312); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_312[0])) != 0) { + { + _hs[0] = 8; + break _hb; + } + } + iL[4] = 25792; + { + _hs[0] = 48; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1174__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_18: { + int _d1 = func_1174__h1(iL, memory, instance); + if (_d1 >= 10000) { + _hs[0] = (_d1 - 10000); + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[3] = (iL[4] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[6] = (iL[5] ^ 1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[6])); + iL[3] = (iL[4] + (iL[6] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[5])); + iL[5] = ((iL[2] + 120) + 16); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + iL[13] = ((iL[2] + 120) + 8); + memory.writeLong((int) iL[13] < 0 ? iL[13] : iL[13] + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) (iL[4] + (iL[6] * 40)) < 0 ? (iL[4] + (iL[6] * 40)) : (iL[4] + (iL[6] * 40)) + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 120, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 200, (int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 24)); + label_42: { + long[] callArgs_47 = new long[2]; + callArgs_47[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12)); + callArgs_47[0] = ((long) (iL[2] + 200)); + long[] callResult_47 = instance.getMachine().call(194, callArgs_47); + if (((int) callResult_47[0]) != 0) { + break label_42; + } + iL[3] = ((iL[2] + 176) + 16); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[5] = ((iL[2] + 176) + 8); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) iL[13] < 0 ? iL[13] : iL[13] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 176, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 120)); + long[] callArgs_48 = new long[2]; + callArgs_48[1] = ((long) (iL[2] + 200)); + callArgs_48[0] = ((long) (iL[2] + 208)); + instance.getMachine().call(192, callArgs_48); + memory.writeLong((int) ((iL[2] + 40) + 8) < 0 ? ((iL[2] + 40) + 8) : ((iL[2] + 40) + 8) + 0, (long) memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + memory.writeI32((int) ((iL[2] + 40) + 16) < 0 ? ((iL[2] + 40) + 16) : ((iL[2] + 40) + 16) + 0, (int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 40, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 176)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 32, (int) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 208)); + long[] callArgs_49 = new long[4]; + callArgs_49[3] = ((long) (iL[2] + 32)); + callArgs_49[2] = ((long) 11125); + callArgs_49[1] = ((long) (iL[2] + 40)); + callArgs_49[0] = ((long) iL[0]); + instance.getMachine().call(1151, callArgs_49); + } + long[] callArgs_50 = new long[1]; + callArgs_50[0] = ((long) 236); + long[] callResult_50 = instance.getMachine().call(1776, callArgs_50); + iL[5] = ((int) callResult_50[0]); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 4, (long) 0L); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 32, (int) 61); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 36, (long) 0L); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) 58052); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 152)); + memory.writeLong((int) (iL[5] + 20) < 0 ? (iL[5] + 20) : (iL[5] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 152) + 8) < 0 ? ((iL[2] + 152) + 8) : ((iL[2] + 152) + 8) + 0)); + memory.writeI32((int) (iL[5] + 28) < 0 ? (iL[5] + 28) : (iL[5] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 152) + 16) < 0 ? ((iL[2] + 152) + 16) : ((iL[2] + 152) + 16) + 0)); + memory.writeLong((int) (iL[5] + 44) < 0 ? (iL[5] + 44) : (iL[5] + 44) + 0, (long) 0L); + iL[6] = (iL[5] + 52); + memory.writeByte((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (byte) (0)); + long[] callArgs_51 = new long[1]; + callArgs_51[0] = ((long) (iL[5] + 56)); + long[] callResult_51 = instance.getMachine().call(154, callArgs_51); + memory.writeLong((int) (iL[5] + 124) < 0 ? (iL[5] + 124) : (iL[5] + 124) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 116) < 0 ? (iL[5] + 116) : (iL[5] + 116) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 108) < 0 ? (iL[5] + 108) : (iL[5] + 108) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 100) < 0 ? (iL[5] + 100) : (iL[5] + 100) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 92) < 0 ? (iL[5] + 92) : (iL[5] + 92) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 136) < 0 ? (iL[5] + 136) : (iL[5] + 136) + 0, (long) 0L); + memory.writeI32((int) (iL[5] + 132) < 0 ? (iL[5] + 132) : (iL[5] + 132) + 0, (int) 1065353216); + memory.writeLong((int) (iL[5] + 144) < 0 ? (iL[5] + 144) : (iL[5] + 144) + 0, (long) 0L); + iL[13] = (iL[5] + 156); + memory.writeLong((int) iL[13] < 0 ? iL[13] : iL[13] + 0, (long) 0L); + memory.writeI32((int) (iL[5] + 152) < 0 ? (iL[5] + 152) : (iL[5] + 152) + 0, (int) 1065353216); + memory.writeLong((int) (iL[5] + 164) < 0 ? (iL[5] + 164) : (iL[5] + 164) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 172) < 0 ? (iL[5] + 172) : (iL[5] + 172) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 180) < 0 ? (iL[5] + 180) : (iL[5] + 180) + 0, (long) 0L); + memory.writeLong((int) (iL[5] + 188) < 0 ? (iL[5] + 188) : (iL[5] + 188) + 0, (long) 0L); + memory.writeI32((int) (iL[5] + 196) < 0 ? (iL[5] + 196) : (iL[5] + 196) + 0, (int) 0); + iL[3] = 1; + long[] callArgs_52 = new long[1]; + callArgs_52[0] = ((long) (iL[5] + 200)); + long[] callResult_52 = instance.getMachine().call(154, callArgs_52); + iL[11] = ((int) callResult_52[0]); + long[] callArgs_53 = new long[2]; + callArgs_53[1] = ((long) (iL[5] + 40)); + callArgs_53[0] = ((long) iL[0]); + long[] callResult_53 = instance.getMachine().call(1178, callArgs_53); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_53[0])) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + long[] callArgs_54 = new long[2]; + callArgs_54[1] = ((long) iL[6]); + callArgs_54[0] = ((long) iL[0]); + long[] callResult_54 = instance.getMachine().call(1180, callArgs_54); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_54[0])) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + long[] callArgs_55 = new long[2]; + callArgs_55[1] = ((long) 30); + callArgs_55[0] = ((long) iL[0]); + long[] callResult_55 = instance.getMachine().call(1160, callArgs_55); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_55[0])) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + long[] callArgs_56 = new long[2]; + callArgs_56[1] = ((long) 16); + callArgs_56[0] = ((long) iL[0]); + long[] callResult_56 = instance.getMachine().call(1160, callArgs_56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_56[0])) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + long[] callArgs_57 = new long[2]; + callArgs_57[1] = ((long) iL[13]); + callArgs_57[0] = ((long) iL[0]); + long[] callResult_57 = instance.getMachine().call(1175, callArgs_57); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_57[0])) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + long[] callArgs_58 = new long[2]; + callArgs_58[1] = ((long) 44); + callArgs_58[0] = ((long) iL[0]); + long[] callResult_58 = instance.getMachine().call(1160, callArgs_58); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_58[0])) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + label_43: { + long[] callArgs_59 = new long[2]; + callArgs_59[1] = ((long) 0); + callArgs_59[0] = ((long) iL[0]); + long[] callResult_59 = instance.getMachine().call(1154, callArgs_59); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_59[0])) != 0) { + break label_43; + } + iL[6] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[13] = (iL[4] + (iL[6] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[13] < 0 ? iL[13] : iL[13] + 36) & 0xFF)) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + iL[12] = (iL[5] + 36); + memory.writeByte((int) (iL[13] + 36) < 0 ? (iL[13] + 36) : (iL[13] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[6] ^ 1))); + label_44: { + label_45: { + long[] callArgs_60 = new long[2]; + callArgs_60[1] = ((long) 0); + callArgs_60[0] = ((long) iL[0]); + long[] callResult_60 = instance.getMachine().call(1154, callArgs_60); + iL[6] = ((int) callResult_60[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((iL[6] + -76), 2) != 0) { + break label_45; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(15, iL[6]) != 0) { + break label_44; + } + long[] callArgs_61 = new long[2]; + callArgs_61[1] = ((long) 14289); + callArgs_61[0] = ((long) (iL[2] + 208)); + long[] callResult_61 = instance.getMachine().call(1167, callArgs_61); + iL[4] = ((int) callResult_61[0]); + long[] callArgs_62 = new long[2]; + callArgs_62[1] = ((long) 13313); + callArgs_62[0] = ((long) (iL[4] + 12)); + long[] callResult_62 = instance.getMachine().call(1167, callArgs_62); + long[] callArgs_63 = new long[2]; + callArgs_63[1] = ((long) 15583); + callArgs_63[0] = ((long) (iL[4] + 24)); + long[] callResult_63 = instance.getMachine().call(1167, callArgs_63); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 116, (int) 3); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 112, (int) iL[4]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 24, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 112)); + long[] callArgs_64 = new long[2]; + callArgs_64[1] = ((long) (iL[2] + 24)); + callArgs_64[0] = ((long) (iL[2] + 120)); + long[] callResult_64 = instance.getMachine().call(1168, callArgs_64); + iL[6] = ((int) callResult_64[0]); + long[] callArgs_65 = new long[3]; + callArgs_65[2] = ((long) 0); + callArgs_65[1] = ((long) iL[6]); + callArgs_65[0] = ((long) iL[0]); + long[] callResult_65 = instance.getMachine().call(1163, callArgs_65); + long[] callArgs_66 = new long[1]; + callArgs_66[0] = ((long) iL[6]); + long[] callResult_66 = instance.getMachine().call(1169, callArgs_66); + label_46: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 35), -1) != 0) { + break label_46; + } + long[] callArgs_67 = new long[1]; + callArgs_67[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 24)); + instance.getMachine().call(1777, callArgs_67); + } + label_47: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 23), -1) != 0) { + break label_47; + } + long[] callArgs_68 = new long[1]; + callArgs_68[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 12)); + instance.getMachine().call(1777, callArgs_68); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 11), -1) != 0) { + break label_43; + } + long[] callArgs_69 = new long[1]; + callArgs_69[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + instance.getMachine().call(1777, callArgs_69); + break label_43; + } + long[] callArgs_70 = new long[2]; + callArgs_70[1] = ((long) (iL[5] + 188)); + callArgs_70[0] = ((long) iL[0]); + long[] callResult_70 = instance.getMachine().call(1181, callArgs_70); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_70[0])) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + memory.writeI32((int) iL[12] < 0 ? iL[12] : iL[12] + 0, (int) 1); + break label_43; + } + iL[6] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[4] = (iL[4] + (iL[6] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 36) & 0xFF)) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + memory.writeByte((int) (iL[4] + 36) < 0 ? (iL[4] + 36) : (iL[4] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[6] ^ 1))); + label_48: { + label_49: { + long[] callArgs_71 = new long[1]; + callArgs_71[0] = ((long) (iL[2] + 208)); + long[] callResult_71 = instance.getMachine().call(154, callArgs_71); + iL[4] = ((int) callResult_71[0]); + long[] callArgs_72 = new long[2]; + callArgs_72[1] = ((long) iL[4]); + callArgs_72[0] = ((long) iL[0]); + long[] callResult_72 = instance.getMachine().call(1166, callArgs_72); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_72[0])) != 0) { + break label_49; + } + long[] callArgs_73 = new long[2]; + callArgs_73[1] = ((long) iL[4]); + callArgs_73[0] = ((long) iL[11]); + long[] callResult_73 = instance.getMachine().call(160, callArgs_73); + memory.writeI32((int) iL[12] < 0 ? iL[12] : iL[12] + 0, (int) 2); + long[] callArgs_74 = new long[2]; + callArgs_74[1] = ((long) 44); + callArgs_74[0] = ((long) iL[0]); + long[] callResult_74 = instance.getMachine().call(1160, callArgs_74); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_74[0])) != 0) { + break label_48; + } + } + long[] callArgs_75 = new long[1]; + callArgs_75[0] = ((long) iL[4]); + long[] callResult_75 = instance.getMachine().call(162, callArgs_75); + { + _hs[0] = 5; + break _hb; + } + } + long[] callArgs_76 = new long[1]; + callArgs_76[0] = ((long) iL[4]); + long[] callResult_76 = instance.getMachine().call(162, callArgs_76); + } + long[] callArgs_77 = new long[2]; + callArgs_77[1] = ((long) 15592); + callArgs_77[0] = ((long) (iL[2] + 120)); + long[] callResult_77 = instance.getMachine().call(1167, callArgs_77); + iL[4] = ((int) callResult_77[0]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 108, (int) 1); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 104, (int) iL[4]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 16, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 104)); + long[] callArgs_78 = new long[2]; + callArgs_78[1] = ((long) (iL[2] + 16)); + callArgs_78[0] = ((long) (iL[2] + 208)); + long[] callResult_78 = instance.getMachine().call(1168, callArgs_78); + iL[6] = ((int) callResult_78[0]); + long[] callArgs_79 = new long[3]; + callArgs_79[2] = ((long) 0); + callArgs_79[1] = ((long) iL[6]); + callArgs_79[0] = ((long) iL[0]); + long[] callResult_79 = instance.getMachine().call(1164, callArgs_79); + iL[13] = ((int) callResult_79[0]); + long[] callArgs_80 = new long[1]; + callArgs_80[0] = ((long) iL[6]); + long[] callResult_80 = instance.getMachine().call(1169, callArgs_80); + label_50: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 11), -1) != 0) { + break label_50; + } + long[] callArgs_81 = new long[1]; + callArgs_81[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + instance.getMachine().call(1777, callArgs_81); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[13]) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + long[] callArgs_82 = new long[2]; + callArgs_82[1] = ((long) iL[0]); + callArgs_82[0] = ((long) (iL[2] + 208)); + instance.getMachine().call(1153, callArgs_82); + memory.writeI32((int) (iL[5] + 184) < 0 ? (iL[5] + 184) : (iL[5] + 184) + 0, (int) memory.readInt((int) (iL[2] + 224) < 0 ? (iL[2] + 224) : (iL[2] + 224) + 0)); + memory.writeLong((int) (iL[5] + 176) < 0 ? (iL[5] + 176) : (iL[5] + 176) + 0, (long) memory.readLong((int) ((iL[2] + 208) + 8) < 0 ? ((iL[2] + 208) + 8) : ((iL[2] + 208) + 8) + 0)); + memory.writeLong((int) (iL[5] + 168) < 0 ? (iL[5] + 168) : (iL[5] + 168) + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 208)); + iL[3] = iL[1]; + label_51: { + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_51; + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 8, (int) iL[4]); + iL[3] = (iL[4] + 4); + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (int) iL[5]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[5]); + iL[7] = (iL[1] + 8); + { + _hs[0] = 3; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1176__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_25: { + label_26: { + label_27: { + label_28: { + label_29: { + int _d3 = func_1176__h3(iL, memory, instance); + if (_d3 == 1) + break label_25; + if (_d3 == 2) + break label_27; + if (_d3 == 3) + break label_28; + if (_d3 == 4) + break label_26; + if (_d3 >= 10000) { + _hs[0] = (_d3 - 10000); + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 19; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_113 = new long[2]; + callArgs_113[1] = ((long) (iL[2] + 1520)); + callArgs_113[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_113); + long[] callArgs_114 = new long[3]; + callArgs_114[2] = ((long) (iL[2] + 1688)); + callArgs_114[1] = ((long) 0); + callArgs_114[0] = ((long) (iL[2] + 1520)); + long[] callResult_114 = instance.getMachine().call(155, callArgs_114); + iL[3] = ((int) callResult_114[0]); + long[] callArgs_115 = new long[2]; + callArgs_115[1] = ((long) iL[3]); + callArgs_115[0] = ((long) (iL[2] + 1320)); + long[] callResult_115 = instance.getMachine().call(159, callArgs_115); + iL[5] = ((int) callResult_115[0]); + long[] callArgs_116 = new long[3]; + callArgs_116[2] = ((long) iL[5]); + callArgs_116[1] = ((long) iL[3]); + callArgs_116[0] = ((long) iL[0]); + long[] callResult_116 = instance.getMachine().call(1170, callArgs_116); + long[] callArgs_117 = new long[1]; + callArgs_117[0] = ((long) iL[5]); + long[] callResult_117 = instance.getMachine().call(162, callArgs_117); + long[] callArgs_118 = new long[1]; + callArgs_118[0] = ((long) 72); + long[] callResult_118 = instance.getMachine().call(1776, callArgs_118); + iL[0] = ((int) callResult_118[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 53); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 55116); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + long[] callArgs_119 = new long[2]; + callArgs_119[1] = ((long) iL[3]); + callArgs_119[0] = ((long) (iL[0] + 36)); + long[] callResult_119 = instance.getMachine().call(159, callArgs_119); + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + label_75: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_75; + } + int ciTableIdx_120 = (int) (memory.readInt((int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) < 0 ? memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) : memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + 4)); + int ciFuncId_120 = instance.table(0).requiredRef(ciTableIdx_120); + com.dylibso.chicory.runtime.Instance ciRefInstance_120 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_120), instance); + if (!ciRefInstance_120.type(ciRefInstance_120.functionType(ciFuncId_120)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_120 = new long[1]; + callArgs_120[0] = ((long) iL[5]); + ciRefInstance_120.getMachine().call(ciFuncId_120, callArgs_120); + } + long[] callArgs_121 = new long[1]; + callArgs_121[0] = ((long) iL[3]); + long[] callResult_121 = instance.getMachine().call(162, callArgs_121); + { + _hs[0] = 20; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 19; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_122 = new long[2]; + callArgs_122[1] = ((long) (iL[2] + 1520)); + callArgs_122[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_122); + long[] callArgs_123 = new long[3]; + callArgs_123[2] = ((long) (iL[2] + 1688)); + callArgs_123[1] = ((long) 0); + callArgs_123[0] = ((long) (iL[2] + 1520)); + long[] callResult_123 = instance.getMachine().call(155, callArgs_123); + iL[3] = ((int) callResult_123[0]); + long[] callArgs_124 = new long[2]; + callArgs_124[1] = ((long) iL[3]); + callArgs_124[0] = ((long) (iL[2] + 1280)); + long[] callResult_124 = instance.getMachine().call(159, callArgs_124); + iL[5] = ((int) callResult_124[0]); + long[] callArgs_125 = new long[3]; + callArgs_125[2] = ((long) iL[5]); + callArgs_125[1] = ((long) iL[3]); + callArgs_125[0] = ((long) iL[0]); + long[] callResult_125 = instance.getMachine().call(1170, callArgs_125); + long[] callArgs_126 = new long[1]; + callArgs_126[0] = ((long) iL[5]); + long[] callResult_126 = instance.getMachine().call(162, callArgs_126); + long[] callArgs_127 = new long[1]; + callArgs_127[0] = ((long) 72); + long[] callResult_127 = instance.getMachine().call(1776, callArgs_127); + iL[0] = ((int) callResult_127[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 56); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 55228); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + long[] callArgs_128 = new long[2]; + callArgs_128[1] = ((long) iL[3]); + callArgs_128[0] = ((long) (iL[0] + 36)); + long[] callResult_128 = instance.getMachine().call(159, callArgs_128); + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + label_76: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_76; + } + int ciTableIdx_129 = (int) (memory.readInt((int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) < 0 ? memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) : memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + 4)); + int ciFuncId_129 = instance.table(0).requiredRef(ciTableIdx_129); + com.dylibso.chicory.runtime.Instance ciRefInstance_129 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_129), instance); + if (!ciRefInstance_129.type(ciRefInstance_129.functionType(ciFuncId_129)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_129 = new long[1]; + callArgs_129[0] = ((long) iL[5]); + ciRefInstance_129.getMachine().call(ciFuncId_129, callArgs_129); + } + long[] callArgs_130 = new long[1]; + callArgs_130[0] = ((long) iL[3]); + long[] callResult_130 = instance.getMachine().call(162, callArgs_130); + { + _hs[0] = 20; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 19; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_131 = new long[2]; + callArgs_131[1] = ((long) (iL[2] + 1520)); + callArgs_131[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_131); + long[] callArgs_132 = new long[3]; + callArgs_132[2] = ((long) (iL[2] + 1688)); + callArgs_132[1] = ((long) 0); + callArgs_132[0] = ((long) (iL[2] + 1520)); + long[] callResult_132 = instance.getMachine().call(155, callArgs_132); + iL[3] = ((int) callResult_132[0]); + long[] callArgs_133 = new long[2]; + callArgs_133[1] = ((long) iL[3]); + callArgs_133[0] = ((long) (iL[2] + 1240)); + long[] callResult_133 = instance.getMachine().call(159, callArgs_133); + iL[5] = ((int) callResult_133[0]); + long[] callArgs_134 = new long[3]; + callArgs_134[2] = ((long) iL[5]); + callArgs_134[1] = ((long) iL[3]); + callArgs_134[0] = ((long) iL[0]); + long[] callResult_134 = instance.getMachine().call(1170, callArgs_134); + long[] callArgs_135 = new long[1]; + callArgs_135[0] = ((long) iL[5]); + long[] callResult_135 = instance.getMachine().call(162, callArgs_135); + long[] callArgs_136 = new long[1]; + callArgs_136[0] = ((long) 72); + long[] callResult_136 = instance.getMachine().call(1776, callArgs_136); + iL[0] = ((int) callResult_136[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 54); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 55340); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + long[] callArgs_137 = new long[2]; + callArgs_137[1] = ((long) iL[3]); + callArgs_137[0] = ((long) (iL[0] + 36)); + long[] callResult_137 = instance.getMachine().call(159, callArgs_137); + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + label_77: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_77; + } + int ciTableIdx_138 = (int) (memory.readInt((int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) < 0 ? memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) : memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + 4)); + int ciFuncId_138 = instance.table(0).requiredRef(ciTableIdx_138); + com.dylibso.chicory.runtime.Instance ciRefInstance_138 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_138), instance); + if (!ciRefInstance_138.type(ciRefInstance_138.functionType(ciFuncId_138)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_138 = new long[1]; + callArgs_138[0] = ((long) iL[5]); + ciRefInstance_138.getMachine().call(ciFuncId_138, callArgs_138); + } + long[] callArgs_139 = new long[1]; + callArgs_139[0] = ((long) iL[3]); + long[] callResult_139 = instance.getMachine().call(162, callArgs_139); + { + _hs[0] = 20; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 19; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_140 = new long[2]; + callArgs_140[1] = ((long) (iL[2] + 1520)); + callArgs_140[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_140); + long[] callArgs_141 = new long[3]; + callArgs_141[2] = ((long) (iL[2] + 1688)); + callArgs_141[1] = ((long) 0); + callArgs_141[0] = ((long) (iL[2] + 1520)); + long[] callResult_141 = instance.getMachine().call(155, callArgs_141); + iL[3] = ((int) callResult_141[0]); + long[] callArgs_142 = new long[2]; + callArgs_142[1] = ((long) iL[3]); + callArgs_142[0] = ((long) (iL[2] + 1200)); + long[] callResult_142 = instance.getMachine().call(159, callArgs_142); + iL[5] = ((int) callResult_142[0]); + long[] callArgs_143 = new long[3]; + callArgs_143[2] = ((long) iL[5]); + callArgs_143[1] = ((long) iL[3]); + callArgs_143[0] = ((long) iL[0]); + long[] callResult_143 = instance.getMachine().call(1170, callArgs_143); + long[] callArgs_144 = new long[1]; + callArgs_144[0] = ((long) iL[5]); + long[] callResult_144 = instance.getMachine().call(162, callArgs_144); + long[] callArgs_145 = new long[1]; + callArgs_145[0] = ((long) 72); + long[] callResult_145 = instance.getMachine().call(1776, callArgs_145); + iL[0] = ((int) callResult_145[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 55); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 55452); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + long[] callArgs_146 = new long[2]; + callArgs_146[1] = ((long) iL[3]); + callArgs_146[0] = ((long) (iL[0] + 36)); + long[] callResult_146 = instance.getMachine().call(159, callArgs_146); + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + label_78: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_78; + } + int ciTableIdx_147 = (int) (memory.readInt((int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) < 0 ? memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) : memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + 4)); + int ciFuncId_147 = instance.table(0).requiredRef(ciTableIdx_147); + com.dylibso.chicory.runtime.Instance ciRefInstance_147 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_147), instance); + if (!ciRefInstance_147.type(ciRefInstance_147.functionType(ciFuncId_147)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_147 = new long[1]; + callArgs_147[0] = ((long) iL[5]); + ciRefInstance_147.getMachine().call(ciFuncId_147, callArgs_147); + } + long[] callArgs_148 = new long[1]; + callArgs_148[0] = ((long) iL[3]); + long[] callResult_148 = instance.getMachine().call(162, callArgs_148); + { + _hs[0] = 20; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 19; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_149 = new long[2]; + callArgs_149[1] = ((long) (iL[2] + 1520)); + callArgs_149[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_149); + long[] callArgs_150 = new long[3]; + callArgs_150[2] = ((long) (iL[2] + 1688)); + callArgs_150[1] = ((long) 0); + callArgs_150[0] = ((long) (iL[2] + 1520)); + long[] callResult_150 = instance.getMachine().call(155, callArgs_150); + iL[3] = ((int) callResult_150[0]); + long[] callArgs_151 = new long[2]; + callArgs_151[1] = ((long) iL[3]); + callArgs_151[0] = ((long) (iL[2] + 1160)); + long[] callResult_151 = instance.getMachine().call(159, callArgs_151); + iL[5] = ((int) callResult_151[0]); + long[] callArgs_152 = new long[3]; + callArgs_152[2] = ((long) iL[5]); + callArgs_152[1] = ((long) iL[3]); + callArgs_152[0] = ((long) iL[0]); + long[] callResult_152 = instance.getMachine().call(1170, callArgs_152); + long[] callArgs_153 = new long[1]; + callArgs_153[0] = ((long) iL[5]); + long[] callResult_153 = instance.getMachine().call(162, callArgs_153); + long[] callArgs_154 = new long[1]; + callArgs_154[0] = ((long) 72); + long[] callResult_154 = instance.getMachine().call(1776, callArgs_154); + iL[0] = ((int) callResult_154[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 57); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 55564); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + long[] callArgs_155 = new long[2]; + callArgs_155[1] = ((long) iL[3]); + callArgs_155[0] = ((long) (iL[0] + 36)); + long[] callResult_155 = instance.getMachine().call(159, callArgs_155); + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + label_79: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_79; + } + int ciTableIdx_156 = (int) (memory.readInt((int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) < 0 ? memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) : memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + 4)); + int ciFuncId_156 = instance.table(0).requiredRef(ciTableIdx_156); + com.dylibso.chicory.runtime.Instance ciRefInstance_156 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_156), instance); + if (!ciRefInstance_156.type(ciRefInstance_156.functionType(ciFuncId_156)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_156 = new long[1]; + callArgs_156[0] = ((long) iL[5]); + ciRefInstance_156.getMachine().call(ciFuncId_156, callArgs_156); + } + long[] callArgs_157 = new long[1]; + callArgs_157[0] = ((long) iL[3]); + long[] callResult_157 = instance.getMachine().call(162, callArgs_157); + { + _hs[0] = 20; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1183__h0(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[5] = ((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(92, iL[5]) != 0) { + break _hb; + } + iL[8] = (iL[10] + 1); + label_20: { + label_21: { + int _d1 = func_1183__h1(iL, lL, memory, instance); + if (_d1 == 1) + break label_20; + if (_d1 >= 10000) { + _hs[0] = (_d1 - 10000); + break _hb; + } + } + iL[0] = (iL[10] + 3); + iL[5] = ((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 3) & 0xFF); + iL[9] = 0; + label_83: while (true) { + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) (iL[2] + 12)); + callArgs_16[0] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[5])); + long[] callResult_16 = instance.getMachine().call(546, callArgs_16); + iL[5] = ((int) callResult_16[0]); + iL[9] = (iL[5] != 0 ? iL[9] : (memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 12) | (iL[9] << 4))); + iL[5] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 1) & 0xFF); + iL[8] = (iL[0] + 1); + iL[0] = iL[8]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(125, iL[5]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_83; + } + break; + } + label_84: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[9], 127) != 0) { + break label_84; + } + label_85: { + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[5]) != 0) { + break label_85; + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (iL[9])); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[0] + 1)); + { + _hs[0] = 1; + break _hb; + } + } + iL[10] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[13] = (iL[0] - iL[10]); + iL[4] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[4], -1) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + label_86: { + label_87: { + iL[5] = (iL[5] - iL[10]); + iL[14] = (iL[5] << 1); + iL[14] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[5], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[14], iL[4]) != 0 ? iL[14] : iL[4]) : 2147483647); + if (iL[14] != 0) { + break label_87; + } + iL[4] = 0; + break label_86; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) iL[14]); + long[] callResult_17 = instance.getMachine().call(1776, callArgs_17); + iL[4] = ((int) callResult_17[0]); + } + iL[5] = (iL[4] + iL[13]); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (iL[9])); + iL[14] = (iL[4] + iL[14]); + iL[15] = (iL[5] + 1); + label_88: { + label_89: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[0]) != 0) { + break label_89; + } + iL[4] = iL[5]; + break label_88; + } + iL[16] = ((iL[10] ^ -1) + iL[0]); + label_90: { + iL[9] = (iL[13] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + break label_90; + } + label_91: while (true) { + iL[5] = (iL[5] + -1); + iL[0] = (iL[0] + -1); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF))); + iL[9] = (iL[9] + -1); + if (iL[9] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_91; + } + break; + } + } + label_92: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], 3) != 0) { + break label_92; + } + iL[9] = (iL[5] + -4); + label_93: while (true) { + memory.writeByte((int) (iL[9] + 3) < 0 ? (iL[9] + 3) : (iL[9] + 3) + 0, (byte) (((int) memory.read((int) (iL[0] + -1) < 0 ? (iL[0] + -1) : (iL[0] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[9] + 2) < 0 ? (iL[9] + 2) : (iL[9] + 2) + 0, (byte) (((int) memory.read((int) (iL[0] + -2) < 0 ? (iL[0] + -2) : (iL[0] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[9] + 1) < 0 ? (iL[9] + 1) : (iL[9] + 1) + 0, (byte) (((int) memory.read((int) (iL[0] + -3) < 0 ? (iL[0] + -3) : (iL[0] + -3) + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (byte) (((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF))); + iL[9] = (iL[9] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_93; + } + break; + } + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[14]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) iL[0]); + instance.getMachine().call(1777, callArgs_18); + { + _hs[0] = 1; + break _hb; + } + } + label_94: { + int _d2 = func_1183__h2(iL, lL, memory, instance); + if (_d2 >= 10000) { + _hs[0] = (_d2 - 10000); + break _hb; + } + } + iL[5] = ((iL[9] & 63) | -128); + label_144: { + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[0]) != 0) { + break label_144; + } + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (byte) (iL[5])); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[9] + 1)); + { + _hs[0] = 1; + break _hb; + } + } + iL[10] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[13] = (iL[9] - iL[10]); + iL[4] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[4], -1) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + label_145: { + label_146: { + iL[0] = (iL[0] - iL[10]); + iL[14] = (iL[0] << 1); + iL[14] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[14], iL[4]) != 0 ? iL[14] : iL[4]) : 2147483647); + if (iL[14] != 0) { + break label_146; + } + iL[4] = 0; + break label_145; + } + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) iL[14]); + long[] callResult_29 = instance.getMachine().call(1776, callArgs_29); + iL[4] = ((int) callResult_29[0]); + } + iL[0] = (iL[4] + iL[13]); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (iL[5])); + iL[14] = (iL[4] + iL[14]); + iL[15] = (iL[0] + 1); + label_147: { + label_148: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + break label_148; + } + iL[4] = iL[0]; + break label_147; + } + iL[16] = ((iL[10] ^ -1) + iL[9]); + label_149: { + iL[5] = (iL[13] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_149; + } + label_150: while (true) { + iL[0] = (iL[0] + -1); + iL[9] = (iL[9] + -1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_150; + } + break; + } + } + label_151: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], 3) != 0) { + break label_151; + } + iL[0] = (iL[0] + -4); + label_152: while (true) { + memory.writeByte((int) (iL[0] + 3) < 0 ? (iL[0] + 3) : (iL[0] + 3) + 0, (byte) (((int) memory.read((int) (iL[9] + -1) < 0 ? (iL[9] + -1) : (iL[9] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 2) < 0 ? (iL[0] + 2) : (iL[0] + 2) + 0, (byte) (((int) memory.read((int) (iL[9] + -2) < 0 ? (iL[9] + -2) : (iL[9] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 1) < 0 ? (iL[0] + 1) : (iL[0] + 1) + 0, (byte) (((int) memory.read((int) (iL[9] + -3) < 0 ? (iL[9] + -3) : (iL[9] + -3) + 0) & 0xFF))); + iL[9] = (iL[9] + -4); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_152; + } + break; + } + } + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[14]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) iL[9]); + instance.getMachine().call(1777, callArgs_30); + { + _hs[0] = 1; + break _hb; + } + } + label_153: { + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) (iL[2] + 8)); + callArgs_31[0] = ((long) iL[9]); + long[] callResult_31 = instance.getMachine().call(546, callArgs_31); + if (((int) callResult_31[0]) != 0) { + break label_153; + } + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) (iL[2] + 4)); + callArgs_32[0] = ((long) (int) (byte) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 2)); + long[] callResult_32 = instance.getMachine().call(546, callArgs_32); + if (((int) callResult_32[0]) != 0) { + break label_153; + } + iL[5] = ((memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 8) << 4) | memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 4)); + label_154: { + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[0]) != 0) { + break label_154; + } + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (byte) (iL[5])); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[9] + 1)); + iL[8] = (iL[10] + 2); + { + _hs[0] = 1; + break _hb; + } + } + iL[8] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[13] = (iL[9] - iL[8]); + iL[4] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[4], -1) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + label_155: { + label_156: { + iL[0] = (iL[0] - iL[8]); + iL[14] = (iL[0] << 1); + iL[14] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[14], iL[4]) != 0 ? iL[14] : iL[4]) : 2147483647); + if (iL[14] != 0) { + break label_156; + } + iL[4] = 0; + break label_155; + } + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) iL[14]); + long[] callResult_33 = instance.getMachine().call(1776, callArgs_33); + iL[4] = ((int) callResult_33[0]); + } + iL[0] = (iL[4] + iL[13]); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (iL[5])); + iL[14] = (iL[4] + iL[14]); + iL[15] = (iL[0] + 1); + label_157: { + label_158: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[9]) != 0) { + break label_158; + } + iL[4] = iL[0]; + break label_157; + } + iL[16] = ((iL[8] ^ -1) + iL[9]); + label_159: { + iL[5] = (iL[13] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_159; + } + label_160: while (true) { + iL[0] = (iL[0] + -1); + iL[9] = (iL[9] + -1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_160; + } + break; + } + } + label_161: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], 3) != 0) { + break label_161; + } + iL[0] = (iL[0] + -4); + label_162: while (true) { + memory.writeByte((int) (iL[0] + 3) < 0 ? (iL[0] + 3) : (iL[0] + 3) + 0, (byte) (((int) memory.read((int) (iL[9] + -1) < 0 ? (iL[9] + -1) : (iL[9] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 2) < 0 ? (iL[0] + 2) : (iL[0] + 2) + 0, (byte) (((int) memory.read((int) (iL[9] + -2) < 0 ? (iL[9] + -2) : (iL[9] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 1) < 0 ? (iL[0] + 1) : (iL[0] + 1) + 0, (byte) (((int) memory.read((int) (iL[9] + -3) < 0 ? (iL[9] + -3) : (iL[9] + -3) + 0) & 0xFF))); + iL[9] = (iL[9] + -4); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_162; + } + break; + } + } + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[14]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + break label_153; + } + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) iL[9]); + instance.getMachine().call(1777, callArgs_34); + } + iL[8] = (iL[10] + 2); + { + _hs[0] = 1; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1212__h0(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_9: { + label_10: { + label_11: { + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) 0); + callArgs_3[0] = ((long) iL[0]); + long[] callResult_3 = instance.getMachine().call(1154, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_3[0])) != 0) { + break label_11; + } + iL[4] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[5] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + memory.writeByte((int) (iL[5] + 36) < 0 ? (iL[5] + 36) : (iL[5] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + label_12: { + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) 0); + callArgs_4[0] = ((long) iL[0]); + long[] callResult_4 = instance.getMachine().call(1154, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_12; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 0); + callArgs_5[0] = ((long) iL[0]); + long[] callResult_5 = instance.getMachine().call(1154, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(10, ((int) callResult_5[0])) != 0) { + break label_12; + } + memory.writeByte((int) (iL[2] + 24) < 0 ? (iL[2] + 24) : (iL[2] + 24) + 0, (byte) (((int) memory.read((int) 0 < 0 ? 0 : 0 + 11551) & 0xFF))); + memory.writeByte((int) iL[2] < 0 ? iL[2] : iL[2] + 19, (byte) (6)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 8, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 15715)); + memory.writeShort((int) iL[2] < 0 ? iL[2] : iL[2] + 12, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 15719) & 0xFFFF))); + memory.writeByte((int) iL[2] < 0 ? iL[2] : iL[2] + 31, (byte) (5)); + memory.writeByte((int) iL[2] < 0 ? iL[2] : iL[2] + 14, (byte) (0)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 20, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 11547)); + memory.writeByte((int) iL[2] < 0 ? iL[2] : iL[2] + 25, (byte) (0)); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) 24); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + iL[4] = ((int) callResult_6[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 8)); + memory.writeI32((int) (iL[4] + 8) < 0 ? (iL[4] + 8) : (iL[4] + 8) + 0, (int) memory.readInt((int) ((iL[2] + 8) + 8) < 0 ? ((iL[2] + 8) + 8) : ((iL[2] + 8) + 8) + 0)); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 20)); + memory.writeI32((int) (iL[4] + 20) < 0 ? (iL[4] + 20) : (iL[4] + 20) + 0, (int) memory.readInt((int) ((iL[2] + 8) + 20) < 0 ? ((iL[2] + 8) + 20) : ((iL[2] + 8) + 20) + 0)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 152, (int) iL[4]); + iL[5] = (iL[4] + 24); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 160, (int) iL[5]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 156, (int) iL[5]); + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) 0); + callArgs_7[1] = ((long) (iL[2] + 152)); + callArgs_7[0] = ((long) iL[0]); + long[] callResult_7 = instance.getMachine().call(1163, callArgs_7); + iL[6] = ((int) callResult_7[0]); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 23), -1) != 0) { + break label_13; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 12)); + instance.getMachine().call(1777, callArgs_8); + } + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 11), -1) != 0) { + break label_14; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + instance.getMachine().call(1777, callArgs_9); + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) iL[4]); + instance.getMachine().call(1777, callArgs_10); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[2] < 0 ? iL[2] : iL[2] + 31), -1) != 0) { + break label_15; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 20)); + instance.getMachine().call(1777, callArgs_11); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[2] < 0 ? iL[2] : iL[2] + 19), -1) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 8)); + instance.getMachine().call(1777, callArgs_12); + { + _hs[0] = 2; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[5] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + memory.writeByte((int) (iL[5] + 36) < 0 ? (iL[5] + 36) : (iL[5] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + label_16: { + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) 0); + callArgs_13[0] = ((long) iL[0]); + long[] callResult_13 = instance.getMachine().call(1154, callArgs_13); + switch((((int) callResult_13[0]) + -13)) { + case 0: + { + break label_16; + } + case 1: + { + break label_10; + } + case 2: + { + break label_10; + } + case 3: + { + break label_10; + } + case 4: + { + break label_10; + } + case 5: + { + break label_16; + } + case 6: + { + break label_10; + } + case 7: + { + break label_10; + } + case 8: + { + break label_16; + } + case 9: + { + break label_10; + } + case 10: + { + break label_16; + } + case 11: + { + break label_10; + } + case 12: + { + break label_16; + } + case 13: + { + break label_16; + } + case 14: + { + break label_10; + } + case 15: + { + break label_10; + } + case 16: + { + break label_10; + } + case 17: + { + break label_10; + } + case 18: + { + break label_16; + } + case 19: + { + break label_10; + } + case 20: + { + break label_10; + } + case 21: + { + break label_10; + } + case 22: + { + break label_10; + } + case 23: + { + break label_10; + } + case 24: + { + break label_10; + } + case 25: + { + break label_10; + } + case 26: + { + break label_10; + } + case 27: + { + break label_10; + } + case 28: + { + break label_10; + } + case 29: + { + break label_10; + } + case 30: + { + break label_10; + } + case 31: + { + break label_10; + } + case 32: + { + break label_10; + } + case 33: + { + break label_16; + } + case 34: + { + break label_10; + } + case 35: + { + break label_16; + } + case 36: + { + break label_10; + } + case 37: + { + break label_16; + } + case 38: + { + break label_10; + } + case 39: + { + break label_10; + } + case 40: + { + break label_10; + } + case 41: + { + break label_10; + } + case 42: + { + break label_10; + } + case 43: + { + break label_10; + } + case 44: + { + break label_10; + } + case 45: + { + break label_10; + } + case 46: + { + break label_10; + } + case 47: + { + break label_10; + } + case 48: + { + break label_10; + } + case 49: + { + break label_10; + } + case 50: + { + break label_10; + } + case 51: + { + break label_10; + } + case 52: + { + break label_10; + } + case 53: + { + break label_10; + } + case 54: + { + break label_10; + } + case 55: + { + break label_10; + } + case 56: + { + break label_10; + } + case 57: + { + break label_10; + } + case 58: + { + break label_10; + } + case 59: + { + break label_16; + } + default: + { + break label_10; + } + } + } + iL[4] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[5] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + memory.writeByte((int) (iL[5] + 36) < 0 ? (iL[5] + 36) : (iL[5] + 36) + 0, (byte) (0)); + iL[6] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) 44); + callArgs_14[0] = ((long) iL[0]); + long[] callResult_14 = instance.getMachine().call(1160, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 160, (int) 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 152, (long) 0L); + iL[6] = 1; + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) (iL[2] + 152)); + callArgs_15[0] = ((long) iL[0]); + long[] callResult_15 = instance.getMachine().call(1183, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_15[0])) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + iL[6] = 1; + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) 44); + callArgs_16[0] = ((long) iL[0]); + long[] callResult_16 = instance.getMachine().call(1160, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_16[0])) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + iL[7] = (int) (byte) memory.read((int) iL[2] < 0 ? iL[2] : iL[2] + 179); + iL[8] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 172); + iL[9] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 168); + iL[0] = 0; + iL[6] = 0; + iL[3] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 156); + iL[4] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[4], iL[3]) != 0) { + break _hb; + } + iL[0] = (iL[3] - iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[0], -1) != 0) { + break label_9; + } + { + _hs[0] = 4; + break _hb; + } + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) 16363); + callArgs_17[0] = ((long) (iL[2] + 8)); + long[] callResult_17 = instance.getMachine().call(1167, callArgs_17); + iL[4] = ((int) callResult_17[0]); + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) 6092); + callArgs_18[0] = ((long) (iL[4] + 12)); + long[] callResult_18 = instance.getMachine().call(1167, callArgs_18); + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) 12348); + callArgs_19[0] = ((long) (iL[4] + 24)); + long[] callResult_19 = instance.getMachine().call(1167, callArgs_19); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) 17326); + callArgs_20[0] = ((long) (iL[4] + 36)); + long[] callResult_20 = instance.getMachine().call(1167, callArgs_20); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) 1196); + callArgs_21[0] = ((long) (iL[4] + 48)); + long[] callResult_21 = instance.getMachine().call(1167, callArgs_21); + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) 13761); + callArgs_22[0] = ((long) (iL[4] + 60)); + long[] callResult_22 = instance.getMachine().call(1167, callArgs_22); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) 6002); + callArgs_23[0] = ((long) (iL[4] + 72)); + long[] callResult_23 = instance.getMachine().call(1167, callArgs_23); + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) 6106); + callArgs_24[0] = ((long) (iL[4] + 84)); + long[] callResult_24 = instance.getMachine().call(1167, callArgs_24); + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) 13034); + callArgs_25[0] = ((long) (iL[4] + 96)); + long[] callResult_25 = instance.getMachine().call(1167, callArgs_25); + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) 17527); + callArgs_26[0] = ((long) (iL[4] + 108)); + long[] callResult_26 = instance.getMachine().call(1167, callArgs_26); + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) 26756); + callArgs_27[0] = ((long) (iL[4] + 120)); + long[] callResult_27 = instance.getMachine().call(1167, callArgs_27); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 148, (int) 11); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 144, (int) iL[4]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 144)); + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) iL[2]); + callArgs_28[0] = ((long) (iL[2] + 152)); + long[] callResult_28 = instance.getMachine().call(1168, callArgs_28); + iL[5] = ((int) callResult_28[0]); + long[] callArgs_29 = new long[3]; + callArgs_29[2] = ((long) 0); + callArgs_29[1] = ((long) iL[5]); + callArgs_29[0] = ((long) iL[0]); + long[] callResult_29 = instance.getMachine().call(1163, callArgs_29); + iL[6] = ((int) callResult_29[0]); + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) iL[5]); + long[] callResult_30 = instance.getMachine().call(1169, callArgs_30); + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 131), -1) != 0) { + break label_17; + } + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 120)); + instance.getMachine().call(1777, callArgs_31); + } + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 119), -1) != 0) { + break label_18; + } + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 108)); + instance.getMachine().call(1777, callArgs_32); + } + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 107), -1) != 0) { + break label_19; + } + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 96)); + instance.getMachine().call(1777, callArgs_33); + } + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 95), -1) != 0) { + break label_20; + } + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 84)); + instance.getMachine().call(1777, callArgs_34); + } + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 83), -1) != 0) { + break label_21; + } + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 72)); + instance.getMachine().call(1777, callArgs_35); + } + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 71), -1) != 0) { + break label_22; + } + long[] callArgs_36 = new long[1]; + callArgs_36[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 60)); + instance.getMachine().call(1777, callArgs_36); + } + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 59), -1) != 0) { + break label_23; + } + long[] callArgs_37 = new long[1]; + callArgs_37[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 48)); + instance.getMachine().call(1777, callArgs_37); + } + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 47), -1) != 0) { + break label_24; + } + long[] callArgs_38 = new long[1]; + callArgs_38[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 36)); + instance.getMachine().call(1777, callArgs_38); + } + label_25: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 35), -1) != 0) { + break label_25; + } + long[] callArgs_39 = new long[1]; + callArgs_39[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 24)); + instance.getMachine().call(1777, callArgs_39); + } + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 23), -1) != 0) { + break label_26; + } + long[] callArgs_40 = new long[1]; + callArgs_40[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 12)); + instance.getMachine().call(1777, callArgs_40); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 11), -1) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + long[] callArgs_41 = new long[1]; + callArgs_41[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + instance.getMachine().call(1777, callArgs_41); + { + _hs[0] = 2; + break _hb; + } + } + iL[10] = ((iL[4] ^ -1) + iL[3]); + long[] callArgs_42 = new long[1]; + callArgs_42[0] = ((long) iL[0]); + long[] callResult_42 = instance.getMachine().call(1776, callArgs_42); + iL[6] = ((int) callResult_42[0]); + label_27: { + label_28: { + iL[5] = (iL[0] & 7); + if (iL[5] != 0) { + break label_28; + } + iL[0] = iL[6]; + break label_27; + } + iL[0] = iL[6]; + label_29: while (true) { + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF))); + iL[0] = (iL[0] + 1); + iL[4] = (iL[4] + 1); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_29; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[10], 7) != 0) { + break _hb; + } + label_30: while (true) { + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 1, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 1) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 2, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 2) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 3, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 3) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 4) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 5, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 5) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 6, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 6) & 0xFF))); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 7, (byte) (((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 7) & 0xFF))); + iL[0] = (iL[0] + 8); + iL[4] = (iL[4] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[3], iL[4]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_30; + } + break; + } + } while (false); + return _hs[0]; + } + + private static int func_1257__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_8: { + int _d1 = func_1257__h1(iL, memory, instance); + if (_d1 >= 10000) { + _hs[0] = (_d1 - 10000); + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[4] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 36) & 0xFF)) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + iL[5] = ((iL[2] + 64) + 16); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) (iL[4] + 16) < 0 ? (iL[4] + 16) : (iL[4] + 16) + 0)); + iL[6] = ((iL[2] + 64) + 8); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) (iL[4] + 8) < 0 ? (iL[4] + 8) : (iL[4] + 8) + 0)); + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 64, (long) memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 136, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 24)); + label_16: { + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12)); + callArgs_30[0] = ((long) (iL[2] + 136)); + long[] callResult_30 = instance.getMachine().call(194, callArgs_30); + if (((int) callResult_30[0]) != 0) { + break label_16; + } + iL[4] = ((iL[2] + 112) + 16); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[5] = ((iL[2] + 112) + 8); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 112, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 64)); + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) (iL[2] + 136)); + callArgs_31[0] = ((long) (iL[2] + 144)); + instance.getMachine().call(192, callArgs_31); + memory.writeLong((int) ((iL[2] + 8) + 8) < 0 ? ((iL[2] + 8) + 8) : ((iL[2] + 8) + 8) + 0, (long) memory.readLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + memory.writeI32((int) ((iL[2] + 8) + 16) < 0 ? ((iL[2] + 8) + 16) : ((iL[2] + 8) + 16) + 0, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 8, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 112)); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 0, (int) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 144)); + long[] callArgs_32 = new long[4]; + callArgs_32[3] = ((long) iL[2]); + callArgs_32[2] = ((long) 11125); + callArgs_32[1] = ((long) (iL[2] + 8)); + callArgs_32[0] = ((long) iL[0]); + instance.getMachine().call(1151, callArgs_32); + } + long[] callArgs_33 = new long[1]; + callArgs_33[0] = ((long) 236); + long[] callResult_33 = instance.getMachine().call(1776, callArgs_33); + iL[4] = ((int) callResult_33[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 4, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 32, (int) 61); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 36, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) 58052); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 88)); + memory.writeLong((int) (iL[4] + 20) < 0 ? (iL[4] + 20) : (iL[4] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 88) + 8) < 0 ? ((iL[2] + 88) + 8) : ((iL[2] + 88) + 8) + 0)); + memory.writeI32((int) (iL[4] + 28) < 0 ? (iL[4] + 28) : (iL[4] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 88) + 16) < 0 ? ((iL[2] + 88) + 16) : ((iL[2] + 88) + 16) + 0)); + memory.writeLong((int) (iL[4] + 44) < 0 ? (iL[4] + 44) : (iL[4] + 44) + 0, (long) 0L); + memory.writeByte((int) (iL[4] + 52) < 0 ? (iL[4] + 52) : (iL[4] + 52) + 0, (byte) (0)); + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) (iL[4] + 56)); + long[] callResult_34 = instance.getMachine().call(154, callArgs_34); + memory.writeLong((int) (iL[4] + 124) < 0 ? (iL[4] + 124) : (iL[4] + 124) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 116) < 0 ? (iL[4] + 116) : (iL[4] + 116) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 108) < 0 ? (iL[4] + 108) : (iL[4] + 108) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 100) < 0 ? (iL[4] + 100) : (iL[4] + 100) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 92) < 0 ? (iL[4] + 92) : (iL[4] + 92) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 136) < 0 ? (iL[4] + 136) : (iL[4] + 136) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 132) < 0 ? (iL[4] + 132) : (iL[4] + 132) + 0, (int) 1065353216); + memory.writeLong((int) (iL[4] + 144) < 0 ? (iL[4] + 144) : (iL[4] + 144) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 156) < 0 ? (iL[4] + 156) : (iL[4] + 156) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 152) < 0 ? (iL[4] + 152) : (iL[4] + 152) + 0, (int) 1065353216); + memory.writeLong((int) (iL[4] + 164) < 0 ? (iL[4] + 164) : (iL[4] + 164) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 172) < 0 ? (iL[4] + 172) : (iL[4] + 172) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 180) < 0 ? (iL[4] + 180) : (iL[4] + 180) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 188) < 0 ? (iL[4] + 188) : (iL[4] + 188) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 196) < 0 ? (iL[4] + 196) : (iL[4] + 196) + 0, (int) 0); + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) (iL[4] + 200)); + long[] callResult_35 = instance.getMachine().call(154, callArgs_35); + iL[6] = ((int) callResult_35[0]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 72, (int) 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 64, (long) 0L); + iL[5] = (iL[4] + 40); + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) iL[5]); + callArgs_36[0] = ((long) iL[0]); + long[] callResult_36 = instance.getMachine().call(1178, callArgs_36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_36[0])) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) iL[5]); + callArgs_37[0] = ((long) iL[0]); + long[] callResult_37 = instance.getMachine().call(1179, callArgs_37); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_37[0])) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + iL[7] = (iL[4] + 36); + label_17: { + label_18: { + long[] callArgs_38 = new long[2]; + callArgs_38[1] = ((long) 0); + callArgs_38[0] = ((long) iL[0]); + long[] callResult_38 = instance.getMachine().call(1154, callArgs_38); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(76, (((int) callResult_38[0]) & -2)) != 0) { + break label_18; + } + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) (iL[4] + 188)); + callArgs_39[0] = ((long) iL[0]); + long[] callResult_39 = instance.getMachine().call(1298, callArgs_39); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_39[0])) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) 1); + break label_17; + } + long[] callArgs_40 = new long[2]; + callArgs_40[1] = ((long) 0); + callArgs_40[0] = ((long) iL[0]); + long[] callResult_40 = instance.getMachine().call(1154, callArgs_40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(15, ((int) callResult_40[0])) != 0) { + break label_17; + } + iL[8] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[9] = (iL[3] + (iL[8] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 36) & 0xFF)) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + memory.writeByte((int) (iL[9] + 36) < 0 ? (iL[9] + 36) : (iL[9] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[8] ^ 1))); + label_19: { + long[] callArgs_41 = new long[1]; + callArgs_41[0] = ((long) (iL[2] + 144)); + long[] callResult_41 = instance.getMachine().call(154, callArgs_41); + iL[8] = ((int) callResult_41[0]); + long[] callArgs_42 = new long[2]; + callArgs_42[1] = ((long) iL[8]); + callArgs_42[0] = ((long) iL[0]); + long[] callResult_42 = instance.getMachine().call(1166, callArgs_42); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_42[0])) != 0) { + break label_19; + } + long[] callArgs_43 = new long[1]; + callArgs_43[0] = ((long) iL[8]); + long[] callResult_43 = instance.getMachine().call(162, callArgs_43); + { + _hs[0] = 3; + break _hb; + } + } + long[] callArgs_44 = new long[2]; + callArgs_44[1] = ((long) iL[8]); + callArgs_44[0] = ((long) iL[6]); + long[] callResult_44 = instance.getMachine().call(160, callArgs_44); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) 2); + long[] callArgs_45 = new long[1]; + callArgs_45[0] = ((long) iL[8]); + long[] callResult_45 = instance.getMachine().call(162, callArgs_45); + } + iL[8] = 0; + long[] callArgs_46 = new long[1]; + callArgs_46[0] = ((long) 32); + long[] callResult_46 = instance.getMachine().call(1776, callArgs_46); + iL[6] = ((int) callResult_46[0]); + memory.writeByte((int) iL[6] < 0 ? iL[6] : iL[6] + 18, (byte) (0)); + memory.writeShort((int) (iL[6] + 16) < 0 ? (iL[6] + 16) : (iL[6] + 16) + 0, (short) (((int) memory.readShort((int) 0 < 0 ? 0 : 0 + 15608) & 0xFFFF))); + memory.writeLong((int) (iL[6] + 8) < 0 ? (iL[6] + 8) : (iL[6] + 8) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 15600)); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 15592)); + long[] callArgs_47 = new long[1]; + callArgs_47[0] = ((long) 12); + long[] callResult_47 = instance.getMachine().call(1776, callArgs_47); + iL[7] = ((int) callResult_47[0]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 144, (int) iL[7]); + iL[9] = (iL[7] + 12); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 152, (int) iL[9]); + long[] callArgs_48 = new long[3]; + callArgs_48[2] = ((long) 18); + callArgs_48[1] = ((long) iL[6]); + callArgs_48[0] = ((long) iL[7]); + instance.getMachine().call(1647, callArgs_48); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 148, (int) iL[9]); + label_20: { + long[] callArgs_49 = new long[2]; + callArgs_49[1] = ((long) 0); + callArgs_49[0] = ((long) iL[0]); + long[] callResult_49 = instance.getMachine().call(1154, callArgs_49); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, ((int) callResult_49[0])) != 0) { + break label_20; + } + iL[8] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[3] = (iL[3] + (iL[8] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[8] ^ 1))); + long[] callArgs_50 = new long[3]; + callArgs_50[2] = ((long) 0); + callArgs_50[1] = ((long) (iL[2] + 144)); + callArgs_50[0] = ((long) iL[0]); + long[] callResult_50 = instance.getMachine().call(1163, callArgs_50); + iL[8] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_50[0])); + } + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[7] < 0 ? iL[7] : iL[7] + 11), -1) != 0) { + break label_21; + } + long[] callArgs_51 = new long[1]; + callArgs_51[0] = ((long) memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0)); + instance.getMachine().call(1777, callArgs_51); + } + long[] callArgs_52 = new long[1]; + callArgs_52[0] = ((long) iL[7]); + instance.getMachine().call(1777, callArgs_52); + long[] callArgs_53 = new long[1]; + callArgs_53[0] = ((long) iL[6]); + instance.getMachine().call(1777, callArgs_53); + if (iL[8] != 0) { + { + _hs[0] = 3; + break _hb; + } + } + long[] callArgs_54 = new long[2]; + callArgs_54[1] = ((long) iL[0]); + callArgs_54[0] = ((long) (iL[2] + 144)); + instance.getMachine().call(1153, callArgs_54); + memory.writeI32((int) (iL[4] + 184) < 0 ? (iL[4] + 184) : (iL[4] + 184) + 0, (int) memory.readInt((int) (iL[2] + 160) < 0 ? (iL[2] + 160) : (iL[2] + 160) + 0)); + memory.writeLong((int) (iL[4] + 176) < 0 ? (iL[4] + 176) : (iL[4] + 176) + 0, (long) memory.readLong((int) (iL[2] + 152) < 0 ? (iL[2] + 152) : (iL[2] + 152) + 0)); + memory.writeLong((int) (iL[4] + 168) < 0 ? (iL[4] + 168) : (iL[4] + 168) + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 144)); + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(2, memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 36)) != 0) { + break label_22; + } + long[] callArgs_55 = new long[2]; + callArgs_55[1] = ((long) 87); + callArgs_55[0] = ((long) iL[0]); + long[] callResult_55 = instance.getMachine().call(1160, callArgs_55); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_55[0])) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + } + long[] callArgs_56 = new long[2]; + callArgs_56[1] = ((long) iL[5]); + callArgs_56[0] = ((long) iL[0]); + long[] callResult_56 = instance.getMachine().call(1297, callArgs_56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_56[0])) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_23; + } + int ciTableIdx_57 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_57 = instance.table(0).requiredRef(ciTableIdx_57); + com.dylibso.chicory.runtime.Instance ciRefInstance_57 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_57), instance); + if (!ciRefInstance_57.type(ciRefInstance_57.functionType(ciFuncId_57)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_57 = new long[1]; + callArgs_57[0] = ((long) iL[0]); + ciRefInstance_57.getMachine().call(ciFuncId_57, callArgs_57); + } + long[] callArgs_58 = new long[1]; + callArgs_58[0] = ((long) (iL[2] + 64)); + long[] callResult_58 = instance.getMachine().call(1299, callArgs_58); + iL[5] = 0; + { + _hs[0] = 1; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1572__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_12: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[110]) != 0) { + break label_12; + } + break _hb; + } + iL[111] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[112] = 10; + iL[113] = (iL[111] + iL[112]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[113]); + iL[114] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[115] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[116] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[114], iL[115]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[116]); + iL[117] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[118] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[119] = iL[117]; + iL[120] = iL[118]; + iL[121] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[119], iL[120]); + iL[122] = 1; + iL[123] = (iL[121] & iL[122]); + label_13: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[123]) != 0) { + break label_13; + } + iL[124] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[124]); + { + _hs[0] = 1; + break _hb; + } + } + iL[125] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[126] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[127] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[128] = (iL[126] * iL[127]); + iL[129] = iL[125]; + iL[130] = iL[128]; + iL[131] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[130], iL[129]); + iL[132] = 1; + iL[133] = (iL[131] & iL[132]); + label_14: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[133]) != 0) { + break label_14; + } + break _hb; + } + iL[134] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[135] = 2; + iL[136] = (iL[134] + iL[135]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[136]); + iL[137] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[138] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[139] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[137], iL[138]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[139]); + iL[140] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[141] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[142] = iL[140]; + iL[143] = iL[141]; + iL[144] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[142], iL[143]); + iL[145] = 1; + iL[146] = (iL[144] & iL[145]); + label_15: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[146]) != 0) { + break label_15; + } + iL[147] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[147]); + { + _hs[0] = 1; + break _hb; + } + } + iL[148] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[149] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[150] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[151] = (iL[149] * iL[150]); + iL[152] = iL[148]; + iL[153] = iL[151]; + iL[154] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[153], iL[152]); + iL[155] = 1; + iL[156] = (iL[154] & iL[155]); + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[156]) != 0) { + break label_16; + } + break _hb; + } + iL[157] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[158] = 4; + iL[159] = (iL[157] + iL[158]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[159]); + iL[160] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[161] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[162] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[160], iL[161]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[162]); + iL[163] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[164] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[165] = iL[163]; + iL[166] = iL[164]; + iL[167] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[165], iL[166]); + iL[168] = 1; + iL[169] = (iL[167] & iL[168]); + label_17: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[169]) != 0) { + break label_17; + } + iL[170] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[170]); + { + _hs[0] = 1; + break _hb; + } + } + iL[171] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[172] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[173] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[174] = (iL[172] * iL[173]); + iL[175] = iL[171]; + iL[176] = iL[174]; + iL[177] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[176], iL[175]); + iL[178] = 1; + iL[179] = (iL[177] & iL[178]); + label_18: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[179]) != 0) { + break label_18; + } + break _hb; + } + iL[180] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[181] = 2; + iL[182] = (iL[180] + iL[181]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[182]); + iL[183] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[184] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[185] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[183], iL[184]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[185]); + iL[186] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[187] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[188] = iL[186]; + iL[189] = iL[187]; + iL[190] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[188], iL[189]); + iL[191] = 1; + iL[192] = (iL[190] & iL[191]); + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[192]) != 0) { + break label_19; + } + iL[193] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[193]); + { + _hs[0] = 1; + break _hb; + } + } + iL[194] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[195] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[196] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[197] = (iL[195] * iL[196]); + iL[198] = iL[194]; + iL[199] = iL[197]; + iL[200] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[199], iL[198]); + iL[201] = 1; + iL[202] = (iL[200] & iL[201]); + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[202]) != 0) { + break label_20; + } + break _hb; + } + iL[203] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[204] = 4; + iL[205] = (iL[203] + iL[204]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[205]); + iL[206] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[207] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[208] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[206], iL[207]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[208]); + iL[209] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[210] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[211] = iL[209]; + iL[212] = iL[210]; + iL[213] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[211], iL[212]); + iL[214] = 1; + iL[215] = (iL[213] & iL[214]); + label_21: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[215]) != 0) { + break label_21; + } + iL[216] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[216]); + { + _hs[0] = 1; + break _hb; + } + } + iL[217] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[218] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[219] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[220] = (iL[218] * iL[219]); + iL[221] = iL[217]; + iL[222] = iL[220]; + iL[223] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[222], iL[221]); + iL[224] = 1; + iL[225] = (iL[223] & iL[224]); + label_22: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[225]) != 0) { + break label_22; + } + break _hb; + } + iL[226] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[227] = 6; + iL[228] = (iL[226] + iL[227]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[228]); + iL[229] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[230] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[231] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[229], iL[230]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[231]); + iL[232] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[233] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[234] = iL[232]; + iL[235] = iL[233]; + iL[236] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[234], iL[235]); + iL[237] = 1; + iL[238] = (iL[236] & iL[237]); + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[238]) != 0) { + break label_23; + } + iL[239] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[239]); + { + _hs[0] = 1; + break _hb; + } + } + iL[240] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[241] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[242] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[243] = (iL[241] * iL[242]); + iL[244] = iL[240]; + iL[245] = iL[243]; + iL[246] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[245], iL[244]); + iL[247] = 1; + iL[248] = (iL[246] & iL[247]); + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[248]) != 0) { + break label_24; + } + break _hb; + } + iL[249] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[250] = 2; + iL[251] = (iL[249] + iL[250]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[251]); + iL[252] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[253] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[254] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[252], iL[253]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[254]); + iL[255] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[256] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[257] = iL[255]; + iL[258] = iL[256]; + iL[259] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[257], iL[258]); + iL[260] = 1; + iL[261] = (iL[259] & iL[260]); + label_25: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[261]) != 0) { + break label_25; + } + iL[262] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[262]); + { + _hs[0] = 1; + break _hb; + } + } + iL[263] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[264] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[265] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[266] = (iL[264] * iL[265]); + iL[267] = iL[263]; + iL[268] = iL[266]; + iL[269] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[268], iL[267]); + iL[270] = 1; + iL[271] = (iL[269] & iL[270]); + label_26: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[271]) != 0) { + break label_26; + } + break _hb; + } + iL[272] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[273] = 6; + iL[274] = (iL[272] + iL[273]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[274]); + iL[275] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[276] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[277] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[275], iL[276]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[277]); + iL[278] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[279] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[280] = iL[278]; + iL[281] = iL[279]; + iL[282] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[280], iL[281]); + iL[283] = 1; + iL[284] = (iL[282] & iL[283]); + label_27: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[284]) != 0) { + break label_27; + } + iL[285] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[285]); + { + _hs[0] = 1; + break _hb; + } + } + iL[286] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[287] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[288] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[289] = (iL[287] * iL[288]); + iL[290] = iL[286]; + iL[291] = iL[289]; + iL[292] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[291], iL[290]); + iL[293] = 1; + iL[294] = (iL[292] & iL[293]); + label_28: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[294]) != 0) { + break label_28; + } + break _hb; + } + iL[295] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[296] = 4; + iL[297] = (iL[295] + iL[296]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[297]); + iL[298] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[299] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[300] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[298], iL[299]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[300]); + iL[301] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[302] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[303] = iL[301]; + iL[304] = iL[302]; + iL[305] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[303], iL[304]); + iL[306] = 1; + iL[307] = (iL[305] & iL[306]); + label_29: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[307]) != 0) { + break label_29; + } + iL[308] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[308]); + { + _hs[0] = 1; + break _hb; + } + } + iL[309] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[310] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[311] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[312] = (iL[310] * iL[311]); + iL[313] = iL[309]; + iL[314] = iL[312]; + iL[315] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[314], iL[313]); + iL[316] = 1; + iL[317] = (iL[315] & iL[316]); + label_30: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[317]) != 0) { + break label_30; + } + break _hb; + } + iL[318] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[319] = 2; + iL[320] = (iL[318] + iL[319]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[320]); + iL[321] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[322] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[323] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[321], iL[322]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[323]); + iL[324] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[325] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[326] = iL[324]; + iL[327] = iL[325]; + iL[328] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[326], iL[327]); + iL[329] = 1; + iL[330] = (iL[328] & iL[329]); + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[330]) != 0) { + break label_31; + } + iL[331] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[331]); + { + _hs[0] = 1; + break _hb; + } + } + iL[332] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[333] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[334] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[335] = (iL[333] * iL[334]); + iL[336] = iL[332]; + iL[337] = iL[335]; + iL[338] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[337], iL[336]); + iL[339] = 1; + iL[340] = (iL[338] & iL[339]); + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[340]) != 0) { + break label_32; + } + break _hb; + } + iL[341] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[342] = 4; + iL[343] = (iL[341] + iL[342]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[343]); + iL[344] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[345] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[346] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[344], iL[345]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[346]); + iL[347] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[348] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[349] = iL[347]; + iL[350] = iL[348]; + iL[351] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[349], iL[350]); + iL[352] = 1; + iL[353] = (iL[351] & iL[352]); + label_33: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[353]) != 0) { + break label_33; + } + iL[354] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[354]); + { + _hs[0] = 1; + break _hb; + } + } + iL[355] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[356] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[357] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[358] = (iL[356] * iL[357]); + iL[359] = iL[355]; + iL[360] = iL[358]; + iL[361] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[360], iL[359]); + iL[362] = 1; + iL[363] = (iL[361] & iL[362]); + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[363]) != 0) { + break label_34; + } + break _hb; + } + iL[364] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[365] = 6; + iL[366] = (iL[364] + iL[365]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[366]); + iL[367] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[368] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[369] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[367], iL[368]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[369]); + iL[370] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[371] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[372] = iL[370]; + iL[373] = iL[371]; + iL[374] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[372], iL[373]); + iL[375] = 1; + iL[376] = (iL[374] & iL[375]); + label_35: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[376]) != 0) { + break label_35; + } + iL[377] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[377]); + { + _hs[0] = 1; + break _hb; + } + } + iL[378] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[379] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[380] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[381] = (iL[379] * iL[380]); + iL[382] = iL[378]; + iL[383] = iL[381]; + iL[384] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[383], iL[382]); + iL[385] = 1; + iL[386] = (iL[384] & iL[385]); + label_36: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[386]) != 0) { + break label_36; + } + break _hb; + } + iL[387] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[388] = 6; + iL[389] = (iL[387] + iL[388]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[389]); + iL[390] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[391] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[392] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[390], iL[391]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[392]); + iL[393] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[394] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[395] = iL[393]; + iL[396] = iL[394]; + iL[397] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[395], iL[396]); + iL[398] = 1; + iL[399] = (iL[397] & iL[398]); + label_37: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[399]) != 0) { + break label_37; + } + iL[400] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[400]); + { + _hs[0] = 1; + break _hb; + } + } + iL[401] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[402] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[403] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[404] = (iL[402] * iL[403]); + iL[405] = iL[401]; + iL[406] = iL[404]; + iL[407] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[406], iL[405]); + iL[408] = 1; + iL[409] = (iL[407] & iL[408]); + label_38: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[409]) != 0) { + break label_38; + } + break _hb; + } + iL[410] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[411] = 2; + iL[412] = (iL[410] + iL[411]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[412]); + iL[413] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[414] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[415] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[413], iL[414]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[415]); + iL[416] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[417] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[418] = iL[416]; + iL[419] = iL[417]; + iL[420] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[418], iL[419]); + iL[421] = 1; + iL[422] = (iL[420] & iL[421]); + label_39: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[422]) != 0) { + break label_39; + } + iL[423] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[423]); + { + _hs[0] = 1; + break _hb; + } + } + iL[424] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[425] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[426] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[427] = (iL[425] * iL[426]); + iL[428] = iL[424]; + iL[429] = iL[427]; + iL[430] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[429], iL[428]); + iL[431] = 1; + iL[432] = (iL[430] & iL[431]); + label_40: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[432]) != 0) { + break label_40; + } + break _hb; + } + iL[433] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[434] = 6; + iL[435] = (iL[433] + iL[434]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[435]); + iL[436] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[437] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[438] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[436], iL[437]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[438]); + iL[439] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[440] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[441] = iL[439]; + iL[442] = iL[440]; + iL[443] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[441], iL[442]); + iL[444] = 1; + iL[445] = (iL[443] & iL[444]); + label_41: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[445]) != 0) { + break label_41; + } + iL[446] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[446]); + { + _hs[0] = 1; + break _hb; + } + } + iL[447] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[448] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[449] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[450] = (iL[448] * iL[449]); + iL[451] = iL[447]; + iL[452] = iL[450]; + iL[453] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[452], iL[451]); + iL[454] = 1; + iL[455] = (iL[453] & iL[454]); + label_42: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[455]) != 0) { + break label_42; + } + break _hb; + } + iL[456] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[457] = 4; + iL[458] = (iL[456] + iL[457]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[458]); + iL[459] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[460] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[461] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[459], iL[460]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[461]); + iL[462] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[463] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[464] = iL[462]; + iL[465] = iL[463]; + iL[466] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[464], iL[465]); + iL[467] = 1; + iL[468] = (iL[466] & iL[467]); + label_43: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[468]) != 0) { + break label_43; + } + iL[469] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[469]); + { + _hs[0] = 1; + break _hb; + } + } + iL[470] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[471] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[472] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[473] = (iL[471] * iL[472]); + iL[474] = iL[470]; + iL[475] = iL[473]; + iL[476] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[475], iL[474]); + iL[477] = 1; + iL[478] = (iL[476] & iL[477]); + label_44: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[478]) != 0) { + break label_44; + } + break _hb; + } + iL[479] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[480] = 2; + iL[481] = (iL[479] + iL[480]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[481]); + iL[482] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[483] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[484] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[482], iL[483]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[484]); + iL[485] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[486] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[487] = iL[485]; + iL[488] = iL[486]; + iL[489] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[487], iL[488]); + iL[490] = 1; + iL[491] = (iL[489] & iL[490]); + label_45: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[491]) != 0) { + break label_45; + } + iL[492] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[492]); + { + _hs[0] = 1; + break _hb; + } + } + iL[493] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[494] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[495] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[496] = (iL[494] * iL[495]); + iL[497] = iL[493]; + iL[498] = iL[496]; + iL[499] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[498], iL[497]); + iL[500] = 1; + iL[501] = (iL[499] & iL[500]); + label_46: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[501]) != 0) { + break label_46; + } + break _hb; + } + iL[502] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[503] = 6; + iL[504] = (iL[502] + iL[503]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[504]); + iL[505] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[506] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[507] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[505], iL[506]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[507]); + iL[508] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[509] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[510] = iL[508]; + iL[511] = iL[509]; + iL[512] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[510], iL[511]); + iL[513] = 1; + iL[514] = (iL[512] & iL[513]); + label_47: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[514]) != 0) { + break label_47; + } + iL[515] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[515]); + { + _hs[0] = 1; + break _hb; + } + } + iL[516] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[517] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[518] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[519] = (iL[517] * iL[518]); + iL[520] = iL[516]; + iL[521] = iL[519]; + iL[522] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[521], iL[520]); + iL[523] = 1; + iL[524] = (iL[522] & iL[523]); + label_48: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[524]) != 0) { + break label_48; + } + break _hb; + } + iL[525] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[526] = 4; + iL[527] = (iL[525] + iL[526]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[527]); + iL[528] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[529] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[530] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[528], iL[529]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[530]); + iL[531] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[532] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[533] = iL[531]; + iL[534] = iL[532]; + iL[535] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[533], iL[534]); + iL[536] = 1; + iL[537] = (iL[535] & iL[536]); + label_49: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[537]) != 0) { + break label_49; + } + iL[538] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[538]); + { + _hs[0] = 1; + break _hb; + } + } + iL[539] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[540] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[541] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[542] = (iL[540] * iL[541]); + iL[543] = iL[539]; + iL[544] = iL[542]; + iL[545] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[544], iL[543]); + iL[546] = 1; + iL[547] = (iL[545] & iL[546]); + label_50: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[547]) != 0) { + break label_50; + } + break _hb; + } + iL[548] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[549] = 6; + iL[550] = (iL[548] + iL[549]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[550]); + iL[551] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[552] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[553] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[551], iL[552]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[553]); + iL[554] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[555] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[556] = iL[554]; + iL[557] = iL[555]; + iL[558] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[556], iL[557]); + iL[559] = 1; + iL[560] = (iL[558] & iL[559]); + label_51: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[560]) != 0) { + break label_51; + } + iL[561] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[561]); + { + _hs[0] = 1; + break _hb; + } + } + iL[562] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[563] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[564] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[565] = (iL[563] * iL[564]); + iL[566] = iL[562]; + iL[567] = iL[565]; + iL[568] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[567], iL[566]); + iL[569] = 1; + iL[570] = (iL[568] & iL[569]); + label_52: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[570]) != 0) { + break label_52; + } + break _hb; + } + iL[571] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[572] = 8; + iL[573] = (iL[571] + iL[572]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[573]); + iL[574] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[575] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[576] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[574], iL[575]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[576]); + iL[577] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[578] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[579] = iL[577]; + iL[580] = iL[578]; + iL[581] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[579], iL[580]); + iL[582] = 1; + iL[583] = (iL[581] & iL[582]); + label_53: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[583]) != 0) { + break label_53; + } + iL[584] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[584]); + { + _hs[0] = 1; + break _hb; + } + } + iL[585] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[586] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[587] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[588] = (iL[586] * iL[587]); + iL[589] = iL[585]; + iL[590] = iL[588]; + iL[591] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[590], iL[589]); + iL[592] = 1; + iL[593] = (iL[591] & iL[592]); + label_54: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[593]) != 0) { + break label_54; + } + break _hb; + } + iL[594] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[595] = 4; + iL[596] = (iL[594] + iL[595]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[596]); + iL[597] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[598] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[599] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[597], iL[598]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[599]); + iL[600] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[601] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[602] = iL[600]; + iL[603] = iL[601]; + iL[604] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[602], iL[603]); + iL[605] = 1; + iL[606] = (iL[604] & iL[605]); + label_55: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[606]) != 0) { + break label_55; + } + iL[607] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[607]); + { + _hs[0] = 1; + break _hb; + } + } + iL[608] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[609] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[610] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[611] = (iL[609] * iL[610]); + iL[612] = iL[608]; + iL[613] = iL[611]; + iL[614] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[613], iL[612]); + iL[615] = 1; + iL[616] = (iL[614] & iL[615]); + label_56: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[616]) != 0) { + break label_56; + } + break _hb; + } + iL[617] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[618] = 2; + iL[619] = (iL[617] + iL[618]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[619]); + iL[620] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[621] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[622] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[620], iL[621]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[622]); + iL[623] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[624] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[625] = iL[623]; + iL[626] = iL[624]; + iL[627] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[625], iL[626]); + iL[628] = 1; + iL[629] = (iL[627] & iL[628]); + label_57: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[629]) != 0) { + break label_57; + } + iL[630] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[630]); + { + _hs[0] = 1; + break _hb; + } + } + iL[631] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[632] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[633] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[634] = (iL[632] * iL[633]); + iL[635] = iL[631]; + iL[636] = iL[634]; + iL[637] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[636], iL[635]); + iL[638] = 1; + iL[639] = (iL[637] & iL[638]); + label_58: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[639]) != 0) { + break label_58; + } + break _hb; + } + iL[640] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[641] = 4; + iL[642] = (iL[640] + iL[641]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[642]); + iL[643] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[644] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[645] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[643], iL[644]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[645]); + iL[646] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[647] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[648] = iL[646]; + iL[649] = iL[647]; + iL[650] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[648], iL[649]); + iL[651] = 1; + iL[652] = (iL[650] & iL[651]); + label_59: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[652]) != 0) { + break label_59; + } + iL[653] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[653]); + { + _hs[0] = 1; + break _hb; + } + } + iL[654] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[655] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[656] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[657] = (iL[655] * iL[656]); + iL[658] = iL[654]; + iL[659] = iL[657]; + iL[660] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[659], iL[658]); + iL[661] = 1; + iL[662] = (iL[660] & iL[661]); + label_60: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[662]) != 0) { + break label_60; + } + break _hb; + } + iL[663] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[664] = 2; + iL[665] = (iL[663] + iL[664]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[665]); + iL[666] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[667] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[668] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[666], iL[667]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[668]); + iL[669] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[670] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[671] = iL[669]; + iL[672] = iL[670]; + iL[673] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[671], iL[672]); + iL[674] = 1; + iL[675] = (iL[673] & iL[674]); + label_61: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[675]) != 0) { + break label_61; + } + iL[676] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[676]); + { + _hs[0] = 1; + break _hb; + } + } + iL[677] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[678] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[679] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[680] = (iL[678] * iL[679]); + iL[681] = iL[677]; + iL[682] = iL[680]; + iL[683] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[682], iL[681]); + iL[684] = 1; + iL[685] = (iL[683] & iL[684]); + label_62: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[685]) != 0) { + break label_62; + } + break _hb; + } + iL[686] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[687] = 4; + iL[688] = (iL[686] + iL[687]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[688]); + iL[689] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[690] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[691] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[689], iL[690]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[691]); + iL[692] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[693] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[694] = iL[692]; + iL[695] = iL[693]; + iL[696] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[694], iL[695]); + iL[697] = 1; + iL[698] = (iL[696] & iL[697]); + label_63: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[698]) != 0) { + break label_63; + } + iL[699] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[699]); + { + _hs[0] = 1; + break _hb; + } + } + iL[700] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[701] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[702] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[703] = (iL[701] * iL[702]); + iL[704] = iL[700]; + iL[705] = iL[703]; + iL[706] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[705], iL[704]); + iL[707] = 1; + iL[708] = (iL[706] & iL[707]); + label_64: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[708]) != 0) { + break label_64; + } + break _hb; + } + iL[709] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[710] = 8; + iL[711] = (iL[709] + iL[710]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[711]); + iL[712] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[713] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[714] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[712], iL[713]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[714]); + iL[715] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[716] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[717] = iL[715]; + iL[718] = iL[716]; + iL[719] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[717], iL[718]); + iL[720] = 1; + iL[721] = (iL[719] & iL[720]); + label_65: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[721]) != 0) { + break label_65; + } + iL[722] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[722]); + { + _hs[0] = 1; + break _hb; + } + } + iL[723] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[724] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[725] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[726] = (iL[724] * iL[725]); + iL[727] = iL[723]; + iL[728] = iL[726]; + iL[729] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[728], iL[727]); + iL[730] = 1; + iL[731] = (iL[729] & iL[730]); + label_66: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[731]) != 0) { + break label_66; + } + break _hb; + } + iL[732] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[733] = 6; + iL[734] = (iL[732] + iL[733]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[734]); + iL[735] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[736] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[737] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[735], iL[736]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[737]); + iL[738] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[739] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[740] = iL[738]; + iL[741] = iL[739]; + iL[742] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[740], iL[741]); + iL[743] = 1; + iL[744] = (iL[742] & iL[743]); + label_67: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[744]) != 0) { + break label_67; + } + iL[745] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[745]); + { + _hs[0] = 1; + break _hb; + } + } + iL[746] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[747] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[748] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[749] = (iL[747] * iL[748]); + iL[750] = iL[746]; + iL[751] = iL[749]; + iL[752] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[751], iL[750]); + iL[753] = 1; + iL[754] = (iL[752] & iL[753]); + label_68: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[754]) != 0) { + break label_68; + } + break _hb; + } + iL[755] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[756] = 4; + iL[757] = (iL[755] + iL[756]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[757]); + iL[758] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[759] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[760] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[758], iL[759]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[760]); + iL[761] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[762] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[763] = iL[761]; + iL[764] = iL[762]; + iL[765] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[763], iL[764]); + iL[766] = 1; + iL[767] = (iL[765] & iL[766]); + label_69: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[767]) != 0) { + break label_69; + } + iL[768] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[768]); + { + _hs[0] = 1; + break _hb; + } + } + iL[769] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[770] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[771] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[772] = (iL[770] * iL[771]); + iL[773] = iL[769]; + iL[774] = iL[772]; + iL[775] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[774], iL[773]); + iL[776] = 1; + iL[777] = (iL[775] & iL[776]); + label_70: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[777]) != 0) { + break label_70; + } + break _hb; + } + iL[778] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[779] = 6; + iL[780] = (iL[778] + iL[779]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[780]); + iL[781] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[782] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[783] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[781], iL[782]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[783]); + iL[784] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[785] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[786] = iL[784]; + iL[787] = iL[785]; + iL[788] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[786], iL[787]); + iL[789] = 1; + iL[790] = (iL[788] & iL[789]); + label_71: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[790]) != 0) { + break label_71; + } + iL[791] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[791]); + { + _hs[0] = 1; + break _hb; + } + } + iL[792] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[793] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[794] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[795] = (iL[793] * iL[794]); + iL[796] = iL[792]; + iL[797] = iL[795]; + iL[798] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[797], iL[796]); + iL[799] = 1; + iL[800] = (iL[798] & iL[799]); + label_72: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[800]) != 0) { + break label_72; + } + break _hb; + } + iL[801] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[802] = 2; + iL[803] = (iL[801] + iL[802]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[803]); + iL[804] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[805] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[806] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[804], iL[805]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[806]); + iL[807] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[808] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[809] = iL[807]; + iL[810] = iL[808]; + iL[811] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[809], iL[810]); + iL[812] = 1; + iL[813] = (iL[811] & iL[812]); + label_73: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[813]) != 0) { + break label_73; + } + iL[814] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[814]); + { + _hs[0] = 1; + break _hb; + } + } + iL[815] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[816] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[817] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[818] = (iL[816] * iL[817]); + iL[819] = iL[815]; + iL[820] = iL[818]; + iL[821] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[820], iL[819]); + iL[822] = 1; + iL[823] = (iL[821] & iL[822]); + label_74: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[823]) != 0) { + break label_74; + } + break _hb; + } + iL[824] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[825] = 4; + iL[826] = (iL[824] + iL[825]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[826]); + iL[827] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[828] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[829] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[827], iL[828]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[829]); + iL[830] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[831] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[832] = iL[830]; + iL[833] = iL[831]; + iL[834] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[832], iL[833]); + iL[835] = 1; + iL[836] = (iL[834] & iL[835]); + label_75: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[836]) != 0) { + break label_75; + } + iL[837] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[837]); + { + _hs[0] = 1; + break _hb; + } + } + iL[838] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[839] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[840] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[841] = (iL[839] * iL[840]); + iL[842] = iL[838]; + iL[843] = iL[841]; + iL[844] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[843], iL[842]); + iL[845] = 1; + iL[846] = (iL[844] & iL[845]); + label_76: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[846]) != 0) { + break label_76; + } + break _hb; + } + iL[847] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[848] = 6; + iL[849] = (iL[847] + iL[848]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[849]); + iL[850] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[851] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[852] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[850], iL[851]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[852]); + iL[853] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[854] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[855] = iL[853]; + iL[856] = iL[854]; + iL[857] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[855], iL[856]); + iL[858] = 1; + iL[859] = (iL[857] & iL[858]); + label_77: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[859]) != 0) { + break label_77; + } + iL[860] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[860]); + { + _hs[0] = 1; + break _hb; + } + } + iL[861] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[862] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[863] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[864] = (iL[862] * iL[863]); + iL[865] = iL[861]; + iL[866] = iL[864]; + iL[867] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[866], iL[865]); + iL[868] = 1; + iL[869] = (iL[867] & iL[868]); + label_78: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[869]) != 0) { + break label_78; + } + break _hb; + } + iL[870] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[871] = 2; + iL[872] = (iL[870] + iL[871]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[872]); + iL[873] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[874] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[875] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[873], iL[874]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[875]); + iL[876] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[877] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[878] = iL[876]; + iL[879] = iL[877]; + iL[880] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[878], iL[879]); + iL[881] = 1; + iL[882] = (iL[880] & iL[881]); + label_79: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[882]) != 0) { + break label_79; + } + iL[883] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[883]); + { + _hs[0] = 1; + break _hb; + } + } + iL[884] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[885] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[886] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[887] = (iL[885] * iL[886]); + iL[888] = iL[884]; + iL[889] = iL[887]; + iL[890] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[889], iL[888]); + iL[891] = 1; + iL[892] = (iL[890] & iL[891]); + label_80: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[892]) != 0) { + break label_80; + } + break _hb; + } + iL[893] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[894] = 6; + iL[895] = (iL[893] + iL[894]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[895]); + iL[896] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[897] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[898] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[896], iL[897]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[898]); + iL[899] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[900] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[901] = iL[899]; + iL[902] = iL[900]; + iL[903] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[901], iL[902]); + iL[904] = 1; + iL[905] = (iL[903] & iL[904]); + label_81: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[905]) != 0) { + break label_81; + } + iL[906] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[906]); + { + _hs[0] = 1; + break _hb; + } + } + iL[907] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[908] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[909] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[910] = (iL[908] * iL[909]); + iL[911] = iL[907]; + iL[912] = iL[910]; + iL[913] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[912], iL[911]); + iL[914] = 1; + iL[915] = (iL[913] & iL[914]); + label_82: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[915]) != 0) { + break label_82; + } + break _hb; + } + iL[916] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[917] = 6; + iL[918] = (iL[916] + iL[917]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[918]); + iL[919] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[920] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[921] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[919], iL[920]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[921]); + iL[922] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[923] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[924] = iL[922]; + iL[925] = iL[923]; + iL[926] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[924], iL[925]); + iL[927] = 1; + iL[928] = (iL[926] & iL[927]); + label_83: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[928]) != 0) { + break label_83; + } + iL[929] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[929]); + { + _hs[0] = 1; + break _hb; + } + } + iL[930] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[931] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[932] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[933] = (iL[931] * iL[932]); + iL[934] = iL[930]; + iL[935] = iL[933]; + iL[936] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[935], iL[934]); + iL[937] = 1; + iL[938] = (iL[936] & iL[937]); + label_84: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[938]) != 0) { + break label_84; + } + break _hb; + } + iL[939] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[940] = 4; + iL[941] = (iL[939] + iL[940]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[941]); + iL[942] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[943] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[944] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[942], iL[943]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[944]); + iL[945] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[946] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[947] = iL[945]; + iL[948] = iL[946]; + iL[949] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[947], iL[948]); + iL[950] = 1; + iL[951] = (iL[949] & iL[950]); + label_85: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[951]) != 0) { + break label_85; + } + iL[952] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[952]); + { + _hs[0] = 1; + break _hb; + } + } + iL[953] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[954] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[955] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[956] = (iL[954] * iL[955]); + iL[957] = iL[953]; + iL[958] = iL[956]; + iL[959] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[958], iL[957]); + iL[960] = 1; + iL[961] = (iL[959] & iL[960]); + label_86: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[961]) != 0) { + break label_86; + } + break _hb; + } + iL[962] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[963] = 2; + iL[964] = (iL[962] + iL[963]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[964]); + iL[965] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[966] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[967] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[965], iL[966]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[967]); + iL[968] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[969] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[970] = iL[968]; + iL[971] = iL[969]; + iL[972] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[970], iL[971]); + iL[973] = 1; + iL[974] = (iL[972] & iL[973]); + label_87: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[974]) != 0) { + break label_87; + } + iL[975] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[975]); + { + _hs[0] = 1; + break _hb; + } + } + iL[976] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[977] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[978] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[979] = (iL[977] * iL[978]); + iL[980] = iL[976]; + iL[981] = iL[979]; + iL[982] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[981], iL[980]); + iL[983] = 1; + iL[984] = (iL[982] & iL[983]); + label_88: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[984]) != 0) { + break label_88; + } + break _hb; + } + iL[985] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[986] = 4; + iL[987] = (iL[985] + iL[986]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[987]); + iL[988] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[989] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[990] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[988], iL[989]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[990]); + iL[991] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[992] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[993] = iL[991]; + iL[994] = iL[992]; + iL[995] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[993], iL[994]); + iL[996] = 1; + iL[997] = (iL[995] & iL[996]); + label_89: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[997]) != 0) { + break label_89; + } + iL[998] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[998]); + { + _hs[0] = 1; + break _hb; + } + } + iL[999] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1000] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1001] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1002] = (iL[1000] * iL[1001]); + iL[1003] = iL[999]; + iL[1004] = iL[1002]; + iL[1005] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1004], iL[1003]); + iL[1006] = 1; + iL[1007] = (iL[1005] & iL[1006]); + label_90: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1007]) != 0) { + break label_90; + } + break _hb; + } + iL[1008] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1009] = 6; + iL[1010] = (iL[1008] + iL[1009]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[1010]); + iL[1011] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1012] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1013] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[1011], iL[1012]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[1013]); + iL[1014] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1015] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1016] = iL[1014]; + iL[1017] = iL[1015]; + iL[1018] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1016], iL[1017]); + iL[1019] = 1; + iL[1020] = (iL[1018] & iL[1019]); + label_91: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1020]) != 0) { + break label_91; + } + iL[1021] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[1021]); + { + _hs[0] = 1; + break _hb; + } + } + iL[1022] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1023] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1024] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1025] = (iL[1023] * iL[1024]); + iL[1026] = iL[1022]; + iL[1027] = iL[1025]; + iL[1028] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1027], iL[1026]); + iL[1029] = 1; + iL[1030] = (iL[1028] & iL[1029]); + label_92: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1030]) != 0) { + break label_92; + } + break _hb; + } + iL[1031] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1032] = 2; + iL[1033] = (iL[1031] + iL[1032]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[1033]); + iL[1034] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1035] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1036] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[1034], iL[1035]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[1036]); + iL[1037] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1038] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1039] = iL[1037]; + iL[1040] = iL[1038]; + iL[1041] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1039], iL[1040]); + iL[1042] = 1; + iL[1043] = (iL[1041] & iL[1042]); + label_93: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1043]) != 0) { + break label_93; + } + iL[1044] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[1044]); + { + _hs[0] = 1; + break _hb; + } + } + iL[1045] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1046] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1047] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1048] = (iL[1046] * iL[1047]); + iL[1049] = iL[1045]; + iL[1050] = iL[1048]; + iL[1051] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1050], iL[1049]); + iL[1052] = 1; + iL[1053] = (iL[1051] & iL[1052]); + label_94: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1053]) != 0) { + break label_94; + } + break _hb; + } + iL[1054] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1055] = 6; + iL[1056] = (iL[1054] + iL[1055]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[1056]); + iL[1057] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1058] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1059] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[1057], iL[1058]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[1059]); + iL[1060] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1061] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1062] = iL[1060]; + iL[1063] = iL[1061]; + iL[1064] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1062], iL[1063]); + iL[1065] = 1; + iL[1066] = (iL[1064] & iL[1065]); + label_95: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1066]) != 0) { + break label_95; + } + iL[1067] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[1067]); + { + _hs[0] = 1; + break _hb; + } + } + iL[1068] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1069] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1070] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1071] = (iL[1069] * iL[1070]); + iL[1072] = iL[1068]; + iL[1073] = iL[1071]; + iL[1074] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1073], iL[1072]); + iL[1075] = 1; + iL[1076] = (iL[1074] & iL[1075]); + label_96: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1076]) != 0) { + break label_96; + } + break _hb; + } + iL[1077] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1078] = 4; + iL[1079] = (iL[1077] + iL[1078]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[1079]); + iL[1080] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1081] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1082] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[1080], iL[1081]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[1082]); + iL[1083] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1084] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1085] = iL[1083]; + iL[1086] = iL[1084]; + iL[1087] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1085], iL[1086]); + iL[1088] = 1; + iL[1089] = (iL[1087] & iL[1088]); + label_97: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1089]) != 0) { + break label_97; + } + iL[1090] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[1090]); + { + _hs[0] = 1; + break _hb; + } + } + iL[1091] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1092] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1093] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1094] = (iL[1092] * iL[1093]); + iL[1095] = iL[1091]; + iL[1096] = iL[1094]; + iL[1097] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1096], iL[1095]); + iL[1098] = 1; + iL[1099] = (iL[1097] & iL[1098]); + label_98: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1099]) != 0) { + break label_98; + } + break _hb; + } + iL[1100] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1101] = 2; + iL[1102] = (iL[1100] + iL[1101]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[1102]); + iL[1103] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1104] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1105] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[1103], iL[1104]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[1105]); + iL[1106] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1107] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1108] = iL[1106]; + iL[1109] = iL[1107]; + iL[1110] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1108], iL[1109]); + iL[1111] = 1; + iL[1112] = (iL[1110] & iL[1111]); + label_99: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1112]) != 0) { + break label_99; + } + iL[1113] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[1113]); + { + _hs[0] = 1; + break _hb; + } + } + iL[1114] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1115] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1116] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1117] = (iL[1115] * iL[1116]); + iL[1118] = iL[1114]; + iL[1119] = iL[1117]; + iL[1120] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1119], iL[1118]); + iL[1121] = 1; + iL[1122] = (iL[1120] & iL[1121]); + label_100: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1122]) != 0) { + break label_100; + } + break _hb; + } + iL[1123] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1124] = 4; + iL[1125] = (iL[1123] + iL[1124]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[1125]); + iL[1126] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1127] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1128] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[1126], iL[1127]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[1128]); + iL[1129] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1130] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1131] = iL[1129]; + iL[1132] = iL[1130]; + iL[1133] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1131], iL[1132]); + iL[1134] = 1; + iL[1135] = (iL[1133] & iL[1134]); + label_101: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1135]) != 0) { + break label_101; + } + iL[1136] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[1136]); + { + _hs[0] = 1; + break _hb; + } + } + iL[1137] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1138] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1139] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1140] = (iL[1138] * iL[1139]); + iL[1141] = iL[1137]; + iL[1142] = iL[1140]; + iL[1143] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1142], iL[1141]); + iL[1144] = 1; + iL[1145] = (iL[1143] & iL[1144]); + label_102: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1145]) != 0) { + break label_102; + } + break _hb; + } + iL[1146] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1147] = 2; + iL[1148] = (iL[1146] + iL[1147]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[1148]); + iL[1149] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1150] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1151] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[1149], iL[1150]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[1151]); + iL[1152] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1153] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1154] = iL[1152]; + iL[1155] = iL[1153]; + iL[1156] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1154], iL[1155]); + iL[1157] = 1; + iL[1158] = (iL[1156] & iL[1157]); + label_103: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1158]) != 0) { + break label_103; + } + iL[1159] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[1159]); + { + _hs[0] = 1; + break _hb; + } + } + iL[1160] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1161] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1162] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1163] = (iL[1161] * iL[1162]); + iL[1164] = iL[1160]; + iL[1165] = iL[1163]; + iL[1166] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1165], iL[1164]); + iL[1167] = 1; + iL[1168] = (iL[1166] & iL[1167]); + label_104: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1168]) != 0) { + break label_104; + } + break _hb; + } + iL[1169] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1170] = 10; + iL[1171] = (iL[1169] + iL[1170]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[1171]); + iL[1172] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1173] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1174] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[1172], iL[1173]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (int) iL[1174]); + iL[1175] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1176] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1177] = iL[1175]; + iL[1178] = iL[1176]; + iL[1179] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1177], iL[1178]); + iL[1180] = 1; + iL[1181] = (iL[1179] & iL[1180]); + label_105: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1181]) != 0) { + break label_105; + } + iL[1182] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 60, (int) iL[1182]); + { + _hs[0] = 1; + break _hb; + } + } + iL[1183] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 56); + iL[1184] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 12); + iL[1185] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1186] = (iL[1184] * iL[1185]); + iL[1187] = iL[1183]; + iL[1188] = iL[1186]; + iL[1189] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[1188], iL[1187]); + iL[1190] = 1; + iL[1191] = (iL[1189] & iL[1190]); + label_106: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1191]) != 0) { + break label_106; + } + break _hb; + } + iL[1192] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 16); + iL[1193] = 2; + iL[1194] = (iL[1192] + iL[1193]); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[1194]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 2; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1783__h0(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_10: { + label_11: { + label_12: { + label_13: { + label_14: { + label_15: { + label_16: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[0], 236) != 0) { + break label_16; + } + label_17: { + iL[9] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657688); + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 11) != 0 ? 16 : ((iL[0] + 19) & -16)); + iL[5] = (iL[7] >>> 3); + iL[6] = (iL[9] >>> iL[5]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[6] & 3)) != 0) { + break label_17; + } + label_18: { + label_19: { + iL[8] = (((iL[6] & 1) | iL[5]) ^ 1); + iL[5] = (iL[8] << 3); + iL[6] = (iL[5] + 657728); + iL[5] = memory.readInt((int) (iL[5] + 657736) < 0 ? (iL[5] + 657736) : (iL[5] + 657736) + 0); + iL[7] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[7], iL[6]) != 0) { + break label_19; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (iL[9] & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, iL[8]))); + break label_18; + } + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 8, (int) iL[7]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 12, (int) iL[6]); + } + iL[6] = (iL[5] + 8); + iL[8] = (iL[8] << 3); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 4, (int) (iL[8] | 3)); + iL[5] = (iL[5] + iL[8]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 4, (int) (memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 4) | 1)); + { + _hs[0] = 1; + break _hb; + } + } + iL[10] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657696); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[7], iL[10]) != 0) { + break label_15; + } + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_20; + } + label_21: { + label_22: { + iL[2] = iL[6]; + iL[6] = (2 << iL[5]); + iL[6] = ((iL[2] << iL[5]) & (iL[6] | (0 - iL[6]))); + iL[5] = com.dylibso.chicory.runtime.OpcodeImpl.I32_CTZ((iL[6] & (0 - iL[6]))); + iL[6] = (iL[5] << 3); + iL[8] = (iL[6] + 657728); + iL[6] = memory.readInt((int) (iL[6] + 657736) < 0 ? (iL[6] + 657736) : (iL[6] + 657736) + 0); + iL[0] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[0], iL[8]) != 0) { + break label_22; + } + iL[9] = (iL[9] & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, iL[5])); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) iL[9]); + break label_21; + } + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 8, (int) iL[0]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[8]); + } + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 4, (int) (iL[7] | 3)); + iL[5] = (iL[5] << 3); + iL[8] = (iL[5] - iL[7]); + memory.writeI32((int) (iL[6] + iL[5]) < 0 ? (iL[6] + iL[5]) : (iL[6] + iL[5]) + 0, (int) iL[8]); + iL[0] = (iL[6] + iL[7]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (int) (iL[8] | 1)); + label_23: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[10]) != 0) { + break label_23; + } + iL[7] = ((iL[10] & -8) + 657728); + iL[5] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657708); + label_24: { + label_25: { + iL[11] = (1 << (iL[10] >>> 3)); + if ((iL[9] & iL[11]) != 0) { + break label_25; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (iL[9] | iL[11])); + iL[11] = iL[7]; + break label_24; + } + iL[11] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 8); + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 12, (int) iL[5]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 8, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 12, (int) iL[7]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 8, (int) iL[11]); + } + iL[6] = (iL[6] + 8); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657708, (int) iL[0]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) iL[8]); + { + _hs[0] = 1; + break _hb; + } + } + iL[12] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657692); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[12]) != 0) { + break label_15; + } + iL[0] = memory.readInt((int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_CTZ((iL[12] & (0 - iL[12]))) << 2) + 657992) < 0 ? ((com.dylibso.chicory.runtime.OpcodeImpl.I32_CTZ((iL[12] & (0 - iL[12]))) << 2) + 657992) : ((com.dylibso.chicory.runtime.OpcodeImpl.I32_CTZ((iL[12] & (0 - iL[12]))) << 2) + 657992) + 0); + iL[5] = ((memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4) & -8) - iL[7]); + iL[8] = iL[0]; + label_26: { + label_27: while (true) { + label_28: { + iL[6] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 16); + if (iL[6] != 0) { + break label_28; + } + iL[6] = memory.readInt((int) (iL[8] + 20) < 0 ? (iL[8] + 20) : (iL[8] + 20) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_26; + } + } + iL[8] = ((memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4) & -8) - iL[7]); + iL[1] = iL[8]; + iL[8] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[8], iL[5]); + iL[5] = (iL[8] != 0 ? iL[1] : iL[5]); + iL[0] = (iL[8] != 0 ? iL[6] : iL[0]); + iL[8] = iL[6]; + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_27; + } + } + iL[13] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 24); + label_29: { + iL[11] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[0], iL[11]) != 0) { + break label_29; + } + iL[6] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[6], memory.readInt((int) 0 < 0 ? 0 : 0 + 657704)); + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 8, (int) iL[6]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 12, (int) iL[11]); + { + _hs[0] = 2; + break _hb; + } + } + label_30: { + iL[8] = (iL[0] + 20); + iL[6] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + if (iL[6] != 0) { + break label_30; + } + iL[6] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_14; + } + iL[8] = (iL[0] + 16); + } + label_31: while (true) { + iL[4] = iL[8]; + iL[11] = iL[6]; + iL[8] = (iL[11] + 20); + iL[6] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_31; + } + iL[8] = (iL[11] + 16); + iL[6] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 16); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_31; + } + break; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) 0); + { + _hs[0] = 2; + break _hb; + } + } + iL[7] = -1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[0], -65) != 0) { + break label_15; + } + iL[6] = (iL[0] + 19); + iL[7] = (iL[6] & -16); + iL[12] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657692); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[12]) != 0) { + break label_15; + } + iL[10] = 0; + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[7], 256) != 0) { + break label_32; + } + iL[10] = 31; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[7], 16777215) != 0) { + break label_32; + } + iL[6] = com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ((iL[6] >>> 8)); + iL[10] = ((((iL[7] >>> (38 - iL[6])) & 1) - (iL[6] << 1)) + 62); + } + iL[5] = (0 - iL[7]); + label_33: { + label_34: { + label_35: { + label_36: { + iL[8] = memory.readInt((int) ((iL[10] << 2) + 657992) < 0 ? ((iL[10] << 2) + 657992) : ((iL[10] << 2) + 657992) + 0); + if (iL[8] != 0) { + break label_36; + } + iL[6] = 0; + iL[11] = 0; + break label_35; + } + iL[6] = 0; + iL[0] = (iL[7] << (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(31, iL[10]) != 0 ? 0 : (25 - (iL[10] >>> 1)))); + iL[11] = 0; + label_37: while (true) { + label_38: { + iL[9] = ((memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 4) & -8) - iL[7]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[5]) != 0) { + break label_38; + } + iL[5] = iL[9]; + iL[11] = iL[8]; + if (iL[9] != 0) { + break label_38; + } + iL[5] = 0; + iL[11] = iL[8]; + iL[6] = iL[8]; + break label_34; + } + iL[9] = memory.readInt((int) (iL[8] + 20) < 0 ? (iL[8] + 20) : (iL[8] + 20) + 0); + iL[8] = memory.readInt((int) ((iL[8] + ((iL[0] >>> 29) & 4)) + 16) < 0 ? ((iL[8] + ((iL[0] >>> 29) & 4)) + 16) : ((iL[8] + ((iL[0] >>> 29) & 4)) + 16) + 0); + iL[6] = (iL[9] != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[8], iL[9]) != 0 ? iL[6] : iL[9]) : iL[6]); + iL[0] = (iL[0] << 1); + if (iL[8] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_37; + } + break; + } + } + label_39: { + if ((iL[6] | iL[11]) != 0) { + break label_39; + } + iL[11] = 0; + iL[6] = (2 << iL[10]); + iL[6] = ((iL[6] | (0 - iL[6])) & iL[12]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_15; + } + iL[6] = memory.readInt((int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_CTZ((iL[6] & (0 - iL[6]))) << 2) + 657992) < 0 ? ((com.dylibso.chicory.runtime.OpcodeImpl.I32_CTZ((iL[6] & (0 - iL[6]))) << 2) + 657992) : ((com.dylibso.chicory.runtime.OpcodeImpl.I32_CTZ((iL[6] & (0 - iL[6]))) << 2) + 657992) + 0); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_33; + } + } + label_40: while (true) { + iL[9] = ((memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4) & -8) - iL[7]); + iL[0] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[9], iL[5]); + label_41: { + iL[8] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 16); + if (iL[8] != 0) { + break label_41; + } + iL[8] = memory.readInt((int) (iL[6] + 20) < 0 ? (iL[6] + 20) : (iL[6] + 20) + 0); + } + iL[5] = (iL[0] != 0 ? iL[9] : iL[5]); + iL[11] = (iL[0] != 0 ? iL[6] : iL[11]); + iL[6] = iL[8]; + if (iL[8] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_40; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[11]) != 0) { + break label_15; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[5], (memory.readInt((int) 0 < 0 ? 0 : 0 + 657696) - iL[7])) != 0) { + break label_15; + } + iL[4] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 24); + label_42: { + iL[0] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[11], iL[0]) != 0) { + break label_42; + } + iL[6] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 8); + com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[6], memory.readInt((int) 0 < 0 ? 0 : 0 + 657704)); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 8, (int) iL[6]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 12, (int) iL[0]); + { + _hs[0] = 3; + break _hb; + } + } + label_43: { + iL[8] = (iL[11] + 20); + iL[6] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + if (iL[6] != 0) { + break label_43; + } + iL[6] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_13; + } + iL[8] = (iL[11] + 16); + } + label_44: while (true) { + iL[9] = iL[8]; + iL[0] = iL[6]; + iL[8] = (iL[0] + 20); + iL[6] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_44; + } + iL[8] = (iL[0] + 16); + iL[6] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 16); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_44; + } + break; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) 0); + { + _hs[0] = 3; + break _hb; + } + } + label_45: { + iL[6] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657696); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[6], iL[7]) != 0) { + break label_45; + } + iL[5] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657708); + label_46: { + label_47: { + iL[8] = (iL[6] - iL[7]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[8], 16) != 0) { + break label_47; + } + iL[0] = (iL[5] + iL[7]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (int) (iL[8] | 1)); + memory.writeI32((int) (iL[5] + iL[6]) < 0 ? (iL[5] + iL[6]) : (iL[5] + iL[6]) + 0, (int) iL[8]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 4, (int) (iL[7] | 3)); + break label_46; + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 4, (int) (iL[6] | 3)); + iL[6] = (iL[5] + iL[6]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 4, (int) (memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4) | 1)); + iL[0] = 0; + iL[8] = 0; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) iL[8]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657708, (int) iL[0]); + iL[6] = (iL[5] + 8); + { + _hs[0] = 1; + break _hb; + } + } + label_48: { + iL[8] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657700); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[8], iL[7]) != 0) { + break label_48; + } + iL[6] = (iL[4] + iL[7]); + iL[5] = (iL[8] - iL[7]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 4, (int) (iL[5] | 1)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657712, (int) iL[6]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657700, (int) iL[5]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 4, (int) (iL[7] | 3)); + iL[6] = (iL[4] + 8); + { + _hs[0] = 1; + break _hb; + } + } + label_49: { + label_50: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) 0 < 0 ? 0 : 0 + 658160)) != 0) { + break label_50; + } + iL[5] = memory.readInt((int) 0 < 0 ? 0 : 0 + 658168); + break label_49; + } + memory.writeLong((int) 0 < 0 ? 0 : 0 + 658172, (long) -1L); + memory.writeLong((int) 0 < 0 ? 0 : 0 + 658164, (long) 281474976776192L); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658160, (int) (((iL[3] + 12) & -16) ^ 1431655768)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658180, (int) 0); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658132, (int) 0); + iL[5] = 65536; + } + iL[6] = 0; + label_51: { + iL[10] = (iL[7] + 71); + iL[0] = (iL[5] + iL[10]); + iL[9] = (0 - iL[5]); + iL[11] = (iL[0] & iL[9]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[11], iL[7]) != 0) { + break label_51; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 48); + { + _hs[0] = 1; + break _hb; + } + } + label_52: { + iL[6] = memory.readInt((int) 0 < 0 ? 0 : 0 + 658128); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_52; + } + label_53: { + iL[5] = memory.readInt((int) 0 < 0 ? 0 : 0 + 658120); + iL[12] = (iL[5] + iL[11]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[12], iL[5]) != 0) { + break label_53; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[12], iL[6]) != 0) { + break label_52; + } + } + iL[6] = 0; + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 48); + { + _hs[0] = 1; + break _hb; + } + } + if ((((int) memory.read((int) 0 < 0 ? 0 : 0 + 658132) & 0xFF) & 4) != 0) { + break label_10; + } + label_54: { + label_55: { + label_56: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_56; + } + iL[6] = 658136; + label_57: while (true) { + label_58: { + iL[5] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[5], iL[4]) != 0) { + break label_58; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((iL[5] + memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4)), iL[4]) != 0) { + break label_55; + } + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 8); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_57; + } + break; + } + } + long[] callArgs_0 = new long[1]; + callArgs_0[0] = ((long) 0); + long[] callResult_0 = instance.getMachine().call(1818, callArgs_0); + iL[0] = ((int) callResult_0[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[0]) != 0) { + break label_11; + } + iL[9] = iL[11]; + label_59: { + iL[6] = memory.readInt((int) 0 < 0 ? 0 : 0 + 658164); + iL[5] = (iL[6] + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[5] & iL[0])) != 0) { + break label_59; + } + iL[9] = ((iL[11] - iL[0]) + ((iL[5] + iL[0]) & (0 - iL[6]))); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[9], iL[7]) != 0) { + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[9], 2147483646) != 0) { + break label_11; + } + label_60: { + iL[6] = memory.readInt((int) 0 < 0 ? 0 : 0 + 658128); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_60; + } + iL[5] = memory.readInt((int) 0 < 0 ? 0 : 0 + 658120); + iL[8] = (iL[5] + iL[9]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[8], iL[5]) != 0) { + break label_11; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[8], iL[6]) != 0) { + break label_11; + } + } + long[] callArgs_1 = new long[1]; + callArgs_1[0] = ((long) iL[9]); + long[] callResult_1 = instance.getMachine().call(1818, callArgs_1); + iL[6] = ((int) callResult_1[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[0], iL[6]) != 0) { + break label_54; + } + break _hb; + } + iL[9] = ((iL[0] - iL[8]) & iL[9]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[9], 2147483646) != 0) { + break label_11; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) iL[9]); + long[] callResult_2 = instance.getMachine().call(1818, callArgs_2); + iL[0] = ((int) callResult_2[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0) + memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4)), iL[0]) != 0) { + break label_12; + } + iL[6] = iL[0]; + } + label_61: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[6]) != 0) { + break label_61; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U((iL[7] + 72), iL[9]) != 0) { + break label_61; + } + label_62: { + iL[5] = memory.readInt((int) 0 < 0 ? 0 : 0 + 658168); + iL[5] = (((iL[10] - iL[9]) + iL[5]) & (0 - iL[5])); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[5], 2147483646) != 0) { + break label_62; + } + iL[0] = iL[6]; + break _hb; + } + label_63: { + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) iL[5]); + long[] callResult_3 = instance.getMachine().call(1818, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, ((int) callResult_3[0])) != 0) { + break label_63; + } + iL[9] = (iL[5] + iL[9]); + iL[0] = iL[6]; + break _hb; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) (0 - iL[9])); + long[] callResult_4 = instance.getMachine().call(1818, callArgs_4); + break label_11; + } + iL[0] = iL[6]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, iL[6]) != 0) { + break _hb; + } + break label_11; + } + iL[11] = 0; + { + _hs[0] = 2; + break _hb; + } + } + iL[0] = 0; + { + _hs[0] = 3; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, iL[0]) != 0) { + break _hb; + } + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658132, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 658132) | 4)); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[11], 2147483646) != 0) { + { + _hs[0] = 4; + break _hb; + } + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) iL[11]); + long[] callResult_5 = instance.getMachine().call(1818, callArgs_5); + iL[0] = ((int) callResult_5[0]); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) 0); + long[] callResult_6 = instance.getMachine().call(1818, callArgs_6); + iL[6] = ((int) callResult_6[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[0]) != 0) { + { + _hs[0] = 4; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[6]) != 0) { + { + _hs[0] = 4; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[6]) != 0) { + { + _hs[0] = 4; + break _hb; + } + } + iL[9] = (iL[6] - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[9], (iL[7] + 56)) != 0) { + { + _hs[0] = 4; + break _hb; + } + } + } while (false); + return _hs[0]; + } + + private static int func_1871__h0(int[] iL, long[] lL, double[] dL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_11: { + label_12: { + int _d3 = func_1871__h3(iL, lL, dL, memory, instance); + if (_d3 == 1) + break label_11; + if (_d3 >= 10000) { + _hs[0] = (_d3 - 10000); + break _hb; + } + } + iL[20] = 0; + iL[25] = -1; + label_43: { + label_44: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(46, ((int) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 0) & 0xFF)) != 0) { + break label_44; + } + iL[1] = iL[23]; + iL[28] = 0; + break label_43; + } + label_45: { + iL[25] = (int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(42, iL[25]) != 0) { + break label_45; + } + label_46: { + label_47: { + iL[1] = ((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 2) + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[1], 9) != 0) { + break label_47; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(36, ((int) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 3) & 0xFF)) != 0) { + break label_47; + } + memory.writeI32((int) (iL[4] + (iL[1] << 2)) < 0 ? (iL[4] + (iL[1] << 2)) : (iL[4] + (iL[1] << 2)) + 0, (int) 10); + iL[1] = (iL[23] + 4); + iL[25] = memory.readInt((int) ((((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 2) << 3) + iL[3]) + -384) < 0 ? ((((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 2) << 3) + iL[3]) + -384) : ((((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 2) << 3) + iL[3]) + -384) + 0); + break label_46; + } + if (iL[18] != 0) { + break label_11; + } + iL[1] = (iL[23] + 2); + label_48: { + if (iL[0] != 0) { + break label_48; + } + iL[25] = 0; + break label_46; + } + iL[23] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 0); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 0, (int) (iL[23] + 4)); + iL[25] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 0); + } + iL[28] = ((iL[25] ^ -1) >>> 31); + break label_43; + } + iL[1] = (iL[23] + 1); + label_49: { + iL[29] = (iL[25] + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[29], 9) != 0) { + break label_49; + } + iL[28] = 1; + iL[25] = 0; + break label_43; + } + iL[30] = 0; + iL[23] = iL[1]; + label_50: while (true) { + iL[25] = -1; + label_51: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[30], 214748364) != 0) { + break label_51; + } + iL[1] = (iL[30] * 10); + iL[25] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[29], (iL[1] ^ 2147483647)) != 0 ? -1 : (iL[1] + iL[29])); + } + iL[28] = 1; + iL[29] = (int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 1); + iL[30] = iL[25]; + iL[1] = (iL[23] + 1); + iL[23] = iL[1]; + iL[29] = (iL[29] + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[29], 10) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_50; + } + break; + } + } + label_52: while (true) { + iL[23] = iL[20]; + iL[20] = (int) (byte) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((iL[20] + -123), -58) != 0) { + break label_11; + } + iL[1] = (iL[1] + 1); + iL[20] = ((int) memory.read((int) ((iL[20] + (iL[23] * 58)) + 61583) < 0 ? ((iL[20] + (iL[23] * 58)) + 61583) : ((iL[20] + (iL[23] * 58)) + 61583) + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((iL[20] + -1), 8) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_52; + } + break; + } + label_53: { + label_54: { + label_55: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(27, iL[20]) != 0) { + break label_55; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[20]) != 0) { + break label_11; + } + label_56: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[24], 0) != 0) { + break label_56; + } + memory.writeI32((int) (iL[4] + (iL[24] << 2)) < 0 ? (iL[4] + (iL[24] << 2)) : (iL[4] + (iL[24] << 2)) + 0, (int) iL[20]); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 56, (long) memory.readLong((int) (iL[3] + (iL[24] << 3)) < 0 ? (iL[3] + (iL[24] << 3)) : (iL[3] + (iL[24] << 3)) + 0)); + break label_54; + } + label_57: { + if (iL[0] != 0) { + break label_57; + } + iL[19] = 0; + { + _hs[0] = 3; + break _hb; + } + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) iL[2]); + callArgs_10[1] = ((long) iL[20]); + callArgs_10[0] = ((long) (iL[6] + 56)); + instance.getMachine().call(1872, callArgs_10); + break label_53; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[24], -1) != 0) { + break label_11; + } + } + iL[20] = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 2; + break _hb; + } + } + } + iL[30] = (iL[26] & -65537); + iL[31] = ((iL[26] & 8192) != 0 ? iL[30] : iL[26]); + label_58: { + int _d2 = func_1871__h2(iL, lL, dL, memory, instance); + if (_d2 >= 10000) { + _hs[0] = (_d2 - 10000); + break _hb; + } + } + label_108: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[28]) != 0) { + break label_108; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[25], 0) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + } + dL[0] = memory.readDouble((int) iL[6] < 0 ? iL[6] : iL[6] + 56); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 108, (int) 0); + label_109: { + label_110: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_S(com.dylibso.chicory.runtime.OpcodeImpl.I64_REINTERPRET_F64(dL[0]), -1L) != 0) { + break label_110; + } + dL[0] = -dL[0]; + iL[33] = 1; + iL[34] = 0; + iL[35] = 2585; + break label_109; + } + label_111: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[31] & 2048)) != 0) { + break label_111; + } + iL[33] = 1; + iL[34] = 0; + iL[35] = 2588; + break label_109; + } + iL[33] = (iL[31] & 1); + iL[35] = (iL[33] != 0 ? 2591 : 2586); + iL[34] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[33]); + } + label_112: { + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_LT(com.dylibso.chicory.runtime.OpcodeImpl.F64_ABS(dL[0]), Double.POSITIVE_INFINITY) != 0) { + break label_112; + } + iL[22] = (iL[33] + 3); + label_113: { + if ((iL[31] & 8192) != 0) { + break label_113; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[27], iL[22]) != 0) { + break label_113; + } + iL[20] = (iL[27] - iL[22]); + iL[23] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[20], 256); + long[] callArgs_22 = new long[3]; + callArgs_22[2] = ((long) (iL[23] != 0 ? iL[20] : 256)); + callArgs_22[1] = ((long) 32); + callArgs_22[0] = ((long) (iL[6] + 624)); + long[] callResult_22 = instance.getMachine().call(1892, callArgs_22); + label_114: { + if (iL[23] != 0) { + break label_114; + } + label_115: while (true) { + label_116: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_116; + } + long[] callArgs_23 = new long[3]; + callArgs_23[2] = ((long) iL[0]); + callArgs_23[1] = ((long) 256); + callArgs_23[0] = ((long) (iL[6] + 624)); + long[] callResult_23 = instance.getMachine().call(1855, callArgs_23); + } + iL[20] = (iL[20] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_115; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_113; + } + long[] callArgs_24 = new long[3]; + callArgs_24[2] = ((long) iL[0]); + callArgs_24[1] = ((long) iL[20]); + callArgs_24[0] = ((long) (iL[6] + 624)); + long[] callResult_24 = instance.getMachine().call(1855, callArgs_24); + } + label_117: { + iL[20] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + if ((iL[20] & 32) != 0) { + break label_117; + } + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) iL[0]); + callArgs_25[1] = ((long) iL[33]); + callArgs_25[0] = ((long) iL[35]); + long[] callResult_25 = instance.getMachine().call(1855, callArgs_25); + iL[20] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + } + label_118: { + if ((iL[20] & 32) != 0) { + break label_118; + } + iL[20] = (iL[32] & 32); + long[] callArgs_26 = new long[3]; + callArgs_26[2] = ((long) iL[0]); + callArgs_26[1] = ((long) 3); + callArgs_26[0] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.F64_NE(dL[0], dL[0]) != 0 ? (iL[20] != 0 ? 12986 : 27034) : (iL[20] != 0 ? 14718 : 27061))); + long[] callResult_26 = instance.getMachine().call(1855, callArgs_26); + } + label_119: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8192, (iL[31] & 73728)) != 0) { + break label_119; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[27], iL[22]) != 0) { + break label_119; + } + iL[20] = (iL[27] - iL[22]); + iL[23] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[20], 256); + long[] callArgs_27 = new long[3]; + callArgs_27[2] = ((long) (iL[23] != 0 ? iL[20] : 256)); + callArgs_27[1] = ((long) 32); + callArgs_27[0] = ((long) (iL[6] + 624)); + long[] callResult_27 = instance.getMachine().call(1892, callArgs_27); + label_120: { + if (iL[23] != 0) { + break label_120; + } + label_121: while (true) { + label_122: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_122; + } + long[] callArgs_28 = new long[3]; + callArgs_28[2] = ((long) iL[0]); + callArgs_28[1] = ((long) 256); + callArgs_28[0] = ((long) (iL[6] + 624)); + long[] callResult_28 = instance.getMachine().call(1855, callArgs_28); + } + iL[20] = (iL[20] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_121; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_119; + } + long[] callArgs_29 = new long[3]; + callArgs_29[2] = ((long) iL[0]); + callArgs_29[1] = ((long) iL[20]); + callArgs_29[0] = ((long) (iL[6] + 624)); + long[] callResult_29 = instance.getMachine().call(1855, callArgs_29); + } + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[22], iL[27]) != 0 ? iL[22] : iL[27]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 2; + break _hb; + } + } + label_123: { + label_124: { + label_125: { + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) (iL[6] + 108)); + callArgs_30[0] = com.dylibso.chicory.wasm.types.Value.doubleToLong(dL[0]); + long[] callResult_30 = instance.getMachine().call(1869, callArgs_30); + dL[0] = com.dylibso.chicory.wasm.types.Value.longToDouble(callResult_30[0]); + dL[0] = (dL[0] + dL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_EQ(dL[0], 0.0) != 0) { + break label_125; + } + iL[20] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 108); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 108, (int) (iL[20] + -1)); + iL[36] = (iL[32] | 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(97, iL[36]) != 0) { + break label_124; + } + { + _hs[0] = 6; + break _hb; + } + } + iL[36] = (iL[32] | 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(97, iL[36]) != 0) { + { + _hs[0] = 6; + break _hb; + } + } + iL[28] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[25], 0) != 0 ? 6 : iL[25]); + iL[21] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 108); + break label_123; + } + iL[21] = (iL[20] + -29); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 108, (int) iL[21]); + iL[28] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[25], 0) != 0 ? 6 : iL[25]); + dL[0] = (dL[0] * 2.68435456E8); + } + iL[37] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[21], 0); + iL[38] = ((iL[37] != 0 ? 0 : 72) << 2); + iL[24] = ((iL[6] + 112) + iL[38]); + iL[22] = iL[24]; + label_126: while (true) { + label_127: { + label_128: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((com.dylibso.chicory.runtime.OpcodeImpl.F64_LT(dL[0], 4.294967296E9) & com.dylibso.chicory.runtime.OpcodeImpl.F64_GE(dL[0], 0.0))) != 0) { + break label_128; + } + iL[20] = com.dylibso.chicory.runtime.OpcodeImpl.I32_TRUNC_F64_U(dL[0]); + break label_127; + } + iL[20] = 0; + } + memory.writeI32((int) iL[22] < 0 ? iL[22] : iL[22] + 0, (int) iL[20]); + iL[22] = (iL[22] + 4); + dL[0] = ((dL[0] - com.dylibso.chicory.runtime.OpcodeImpl.F64_CONVERT_I32_U(iL[20])) * 1.0E9); + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_NE(dL[0], 0.0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_126; + } + break; + } + label_129: { + label_130: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[21], 1) != 0) { + break label_130; + } + iL[20] = iL[22]; + iL[23] = iL[24]; + break label_129; + } + iL[23] = iL[24]; + label_131: while (true) { + iL[21] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[21], 29) != 0 ? iL[21] : 29); + label_132: { + iL[20] = (iL[22] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[20], iL[23]) != 0) { + break label_132; + } + lL[2] = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(iL[21]); + lL[1] = 0L; + label_133: while (true) { + lL[1] = ((((long) memory.readInt((int) iL[20] < 0 ? iL[20] : iL[20] + 0) & 0xFFFFFFFFL) << lL[2]) + (lL[1] & 4294967295L)); + lL[0] = lL[1]; + lL[1] = com.dylibso.chicory.runtime.OpcodeImpl.I64_DIV_U(lL[1], 1000000000L); + memory.writeI32((int) iL[20] < 0 ? iL[20] : iL[20] + 0, (int) (lL[0] - (lL[1] * 1000000000L))); + iL[20] = (iL[20] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[20], iL[23]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_133; + } + break; + } + iL[20] = (int) lL[1]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[20]) != 0) { + break label_132; + } + iL[23] = (iL[23] + -4); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 0, (int) iL[20]); + } + label_134: { + label_135: while (true) { + iL[20] = iL[22]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[20], iL[23]) != 0) { + break label_134; + } + iL[22] = (iL[20] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) iL[22] < 0 ? iL[22] : iL[22] + 0)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_135; + } + break; + } + } + iL[21] = (memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 108) - iL[21]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 108, (int) iL[21]); + iL[22] = iL[20]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[21], 0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_131; + } + break; + } + } + label_136: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[21], -1) != 0) { + break label_136; + } + iL[39] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U((iL[28] + 25), 9) + 1); + label_137: while (true) { + iL[22] = (0 - iL[21]); + iL[25] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[22], 9) != 0 ? iL[22] : 9); + label_138: { + label_139: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[23], iL[20]) != 0) { + break label_139; + } + iL[22] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 0); + break label_138; + } + iL[30] = (1000000000 >>> iL[25]); + iL[29] = ((-1 << iL[25]) ^ -1); + iL[21] = 0; + iL[22] = iL[23]; + label_140: while (true) { + iL[26] = memory.readInt((int) iL[22] < 0 ? iL[22] : iL[22] + 0); + memory.writeI32((int) iL[22] < 0 ? iL[22] : iL[22] + 0, (int) ((iL[26] >>> iL[25]) + iL[21])); + iL[21] = ((iL[26] & iL[29]) * iL[30]); + iL[22] = (iL[22] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[22], iL[20]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_140; + } + break; + } + iL[22] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[21]) != 0) { + break label_138; + } + memory.writeI32((int) iL[20] < 0 ? iL[20] : iL[20] + 0, (int) iL[21]); + iL[20] = (iL[20] + 4); + } + iL[21] = (memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 108) + iL[25]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 108, (int) iL[21]); + iL[23] = (iL[23] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[22]) << 2)); + iL[22] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(102, iL[36]) != 0 ? iL[24] : iL[23]); + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(((iL[20] - iL[22]) >> 2), iL[39]) != 0 ? (iL[22] + (iL[39] << 2)) : iL[20]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[21], 0) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_137; + } + break; + } + } + iL[26] = 0; + label_141: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[23], iL[20]) != 0) { + break label_141; + } + iL[26] = (((iL[24] - iL[23]) >> 2) * 9); + iL[21] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[21], 10) != 0) { + break label_141; + } + iL[22] = 10; + label_142: while (true) { + iL[26] = (iL[26] + 1); + iL[22] = (iL[22] * 10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[21], iL[22]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_142; + } + break; + } + } + label_143: { + iL[29] = com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(103, iL[36]); + iL[22] = ((iL[28] - (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(102, iL[36]) != 0 ? 0 : iL[26])) - (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[28]) & iL[29])); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[22], ((((iL[20] - iL[24]) >> 2) * 9) + -9)) != 0) { + break label_143; + } + iL[21] = (iL[22] + 9216); + iL[25] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S(iL[21], 9); + iL[40] = (iL[25] << 2); + iL[37] = ((iL[37] != 0 ? 1 : 73) << 2); + iL[30] = ((iL[40] + ((iL[6] + 112) + iL[37])) + -4096); + iL[22] = 10; + label_144: { + iL[25] = (iL[21] - (iL[25] * 9)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[25], 7) != 0) { + break label_144; + } + iL[39] = (8 - iL[25]); + iL[21] = (iL[39] & 7); + iL[22] = 10; + label_145: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((iL[25] + -1), 7) != 0) { + break label_145; + } + iL[25] = (iL[39] & -8); + iL[22] = 10; + label_146: while (true) { + iL[22] = (iL[22] * 100000000); + iL[25] = (iL[25] + -8); + if (iL[25] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_146; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[21]) != 0) { + break label_144; + } + label_147: while (true) { + iL[22] = (iL[22] * 10); + iL[21] = (iL[21] + -1); + if (iL[21] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_147; + } + break; + } + } + iL[39] = (iL[30] + 4); + label_148: { + label_149: { + iL[21] = memory.readInt((int) iL[30] < 0 ? iL[30] : iL[30] + 0); + iL[36] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[21], iL[22]); + iL[25] = (iL[21] - (iL[36] * iL[22])); + if (iL[25] != 0) { + break label_149; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[20], iL[39]) != 0) { + break label_148; + } + } + label_150: { + label_151: { + if ((iL[36] & 1) != 0) { + break label_151; + } + dL[0] = 9.007199254740992E15; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1000000000, iL[22]) != 0) { + break label_150; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[30], iL[23]) != 0) { + break label_150; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) (iL[30] + -4) < 0 ? (iL[30] + -4) : (iL[30] + -4) + 0) & 0xFF) & 1)) != 0) { + break label_150; + } + } + dL[0] = 9.007199254740994E15; + } + iL[5] = iL[39]; + iL[39] = (iL[22] >>> 1); + dL[1] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[25], iL[39]) != 0 ? 0.5 : (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[39], iL[25]) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[20], iL[5]) != 0 ? 1.0 : 1.5) : 1.5)); + label_152: { + if (iL[34] != 0) { + break label_152; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(45, ((int) memory.read((int) iL[35] < 0 ? iL[35] : iL[35] + 0) & 0xFF)) != 0) { + break label_152; + } + dL[1] = -dL[1]; + dL[0] = -dL[0]; + } + iL[21] = (iL[21] - iL[25]); + memory.writeI32((int) iL[30] < 0 ? iL[30] : iL[30] + 0, (int) iL[21]); + if (com.dylibso.chicory.runtime.OpcodeImpl.F64_EQ((dL[0] + dL[1]), dL[0]) != 0) { + break label_148; + } + iL[22] = (iL[21] + iL[22]); + memory.writeI32((int) iL[30] < 0 ? iL[30] : iL[30] + 0, (int) iL[22]); + label_153: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[22], 1000000000) != 0) { + break label_153; + } + iL[22] = (iL[9] + (iL[37] + iL[40])); + label_154: while (true) { + memory.writeI32((int) (iL[22] + 4) < 0 ? (iL[22] + 4) : (iL[22] + 4) + 0, (int) 0); + label_155: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[22], iL[23]) != 0) { + break label_155; + } + iL[23] = (iL[23] + -4); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 0, (int) 0); + } + iL[21] = (memory.readInt((int) iL[22] < 0 ? iL[22] : iL[22] + 0) + 1); + memory.writeI32((int) iL[22] < 0 ? iL[22] : iL[22] + 0, (int) iL[21]); + iL[22] = (iL[22] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[21], 999999999) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_154; + } + break; + } + iL[30] = (iL[22] + 4); + } + iL[26] = (((iL[24] - iL[23]) >> 2) * 9); + iL[21] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[21], 10) != 0) { + break label_148; + } + iL[22] = 10; + label_156: while (true) { + iL[26] = (iL[26] + 1); + iL[22] = (iL[22] * 10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[21], iL[22]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_156; + } + break; + } + } + iL[22] = (iL[30] + 4); + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], iL[22]) != 0 ? iL[22] : iL[20]); + } + iL[22] = ((iL[8] + iL[20]) - iL[38]); + label_157: { + label_158: while (true) { + iL[21] = iL[22]; + iL[30] = iL[20]; + iL[25] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[30], iL[23]); + if (iL[25] != 0) { + break label_157; + } + iL[22] = (iL[21] + -4); + iL[20] = (iL[30] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) iL[20] < 0 ? iL[20] : iL[20] + 0)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_158; + } + break; + } + } + label_159: { + label_160: { + if (iL[29] != 0) { + break label_160; + } + iL[39] = (iL[31] & 8); + break label_159; + } + iL[20] = (iL[28] != 0 ? iL[28] : 1); + iL[22] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[20], iL[26]) & com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[26], -5)); + iL[28] = ((iL[22] != 0 ? (iL[26] ^ -1) : -1) + iL[20]); + iL[32] = ((iL[22] != 0 ? -1 : -2) + iL[32]); + iL[39] = (iL[31] & 8); + if (iL[39] != 0) { + break label_159; + } + iL[20] = -9; + label_161: { + if (iL[25] != 0) { + break label_161; + } + iL[25] = memory.readInt((int) (iL[30] + -4) < 0 ? (iL[30] + -4) : (iL[30] + -4) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[25]) != 0) { + break label_161; + } + iL[20] = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(iL[25], 10) != 0) { + break label_161; + } + iL[22] = 10; + iL[20] = 0; + label_162: while (true) { + iL[20] = (iL[20] + -1); + iL[22] = (iL[22] * 10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(com.dylibso.chicory.runtime.OpcodeImpl.I32_REM_U(iL[25], iL[22])) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_162; + } + break; + } + } + iL[22] = (((iL[21] >> 2) * 9) + -9); + label_163: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(70, (iL[32] & -33)) != 0) { + break label_163; + } + iL[39] = 0; + iL[20] = (iL[22] + iL[20]); + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[20], 0) != 0 ? iL[20] : 0); + iL[28] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[28], iL[20]) != 0 ? iL[28] : iL[20]); + break label_159; + } + iL[39] = 0; + iL[20] = ((iL[22] + iL[26]) + iL[20]); + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[20], 0) != 0 ? iL[20] : 0); + iL[28] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[28], iL[20]) != 0 ? iL[28] : iL[20]); + } + iL[34] = (iL[28] | iL[39]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[28], (iL[34] != 0 ? 2147483645 : 2147483646)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[36] = ((iL[28] + com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[34])) + 1); + label_164: { + label_165: { + iL[37] = com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(70, (iL[32] & -33)); + if (iL[37] != 0) { + break label_165; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[26], (iL[36] ^ 2147483647)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[26], 0) != 0 ? iL[26] : 0); + break label_164; + } + label_166: { + label_167: { + if (iL[26] != 0) { + break label_167; + } + iL[21] = iL[7]; + iL[22] = iL[7]; + break label_166; + } + iL[20] = (iL[26] >> 31); + iL[20] = ((iL[26] ^ iL[20]) - iL[20]); + iL[21] = iL[7]; + iL[22] = iL[7]; + label_168: while (true) { + iL[22] = (iL[22] + -1); + iL[25] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[20], 10); + memory.writeByte((int) iL[22] < 0 ? iL[22] : iL[22] + 0, (byte) (((iL[20] - (iL[25] * 10)) | 48))); + iL[21] = (iL[21] + -1); + iL[29] = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 9); + iL[20] = iL[25]; + if (iL[29] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_168; + } + break; + } + } + label_169: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((iL[7] - iL[21]), 1) != 0) { + break label_169; + } + iL[22] = (iL[22] + (iL[16] - iL[21])); + long[] callArgs_31 = new long[3]; + callArgs_31[2] = ((long) (iL[15] + iL[21])); + callArgs_31[1] = ((long) 48); + callArgs_31[0] = ((long) iL[22]); + long[] callResult_31 = instance.getMachine().call(1892, callArgs_31); + } + iL[38] = (iL[22] + -2); + memory.writeByte((int) iL[38] < 0 ? iL[38] : iL[38] + 0, (byte) (iL[32])); + memory.writeByte((int) (iL[22] + -1) < 0 ? (iL[22] + -1) : (iL[22] + -1) + 0, (byte) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[26], 0) != 0 ? 45 : 43))); + iL[20] = (iL[7] - iL[38]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[20], (iL[36] ^ 2147483647)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + } + iL[20] = (iL[20] + iL[36]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[20], (iL[33] ^ 2147483647)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[29] = (iL[20] + iL[33]); + label_170: { + iL[31] = (iL[31] & 73728); + if (iL[31] != 0) { + break label_170; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[27], iL[29]) != 0) { + break label_170; + } + iL[20] = (iL[27] - iL[29]); + iL[22] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[20], 256); + long[] callArgs_32 = new long[3]; + callArgs_32[2] = ((long) (iL[22] != 0 ? iL[20] : 256)); + callArgs_32[1] = ((long) 32); + callArgs_32[0] = ((long) (iL[6] + 624)); + long[] callResult_32 = instance.getMachine().call(1892, callArgs_32); + label_171: { + if (iL[22] != 0) { + break label_171; + } + label_172: while (true) { + label_173: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_173; + } + long[] callArgs_33 = new long[3]; + callArgs_33[2] = ((long) iL[0]); + callArgs_33[1] = ((long) 256); + callArgs_33[0] = ((long) (iL[6] + 624)); + long[] callResult_33 = instance.getMachine().call(1855, callArgs_33); + } + iL[20] = (iL[20] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_172; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_170; + } + long[] callArgs_34 = new long[3]; + callArgs_34[2] = ((long) iL[0]); + callArgs_34[1] = ((long) iL[20]); + callArgs_34[0] = ((long) (iL[6] + 624)); + long[] callResult_34 = instance.getMachine().call(1855, callArgs_34); + } + label_174: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_174; + } + long[] callArgs_35 = new long[3]; + callArgs_35[2] = ((long) iL[0]); + callArgs_35[1] = ((long) iL[33]); + callArgs_35[0] = ((long) iL[35]); + long[] callResult_35 = instance.getMachine().call(1855, callArgs_35); + } + label_175: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(65536, iL[31]) != 0) { + break label_175; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[27], iL[29]) != 0) { + break label_175; + } + iL[20] = (iL[27] - iL[29]); + iL[22] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[20], 256); + long[] callArgs_36 = new long[3]; + callArgs_36[2] = ((long) (iL[22] != 0 ? iL[20] : 256)); + callArgs_36[1] = ((long) 48); + callArgs_36[0] = ((long) (iL[6] + 624)); + long[] callResult_36 = instance.getMachine().call(1892, callArgs_36); + label_176: { + if (iL[22] != 0) { + break label_176; + } + label_177: while (true) { + label_178: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_178; + } + long[] callArgs_37 = new long[3]; + callArgs_37[2] = ((long) iL[0]); + callArgs_37[1] = ((long) 256); + callArgs_37[0] = ((long) (iL[6] + 624)); + long[] callResult_37 = instance.getMachine().call(1855, callArgs_37); + } + iL[20] = (iL[20] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_177; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_175; + } + long[] callArgs_38 = new long[3]; + callArgs_38[2] = ((long) iL[0]); + callArgs_38[1] = ((long) iL[20]); + callArgs_38[0] = ((long) (iL[6] + 624)); + long[] callResult_38 = instance.getMachine().call(1855, callArgs_38); + } + if (iL[37] != 0) { + { + _hs[0] = 7; + break _hb; + } + } + iL[26] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[23], iL[24]) != 0 ? iL[24] : iL[23]); + iL[25] = iL[26]; + label_179: while (true) { + label_180: { + label_181: { + label_182: { + label_183: { + iL[20] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[20]) != 0) { + break label_183; + } + iL[22] = 8; + label_184: while (true) { + iL[23] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[20], 10); + memory.writeByte((int) ((iL[6] + 80) + iL[22]) < 0 ? ((iL[6] + 80) + iL[22]) : ((iL[6] + 80) + iL[22]) + 0, (byte) (((iL[20] - (iL[23] * 10)) | 48))); + iL[22] = (iL[22] + -1); + iL[21] = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 9); + iL[20] = iL[23]; + if (iL[21] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_184; + } + break; + } + iL[23] = (iL[22] + 1); + iL[20] = (iL[23] + (iL[6] + 80)); + label_185: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[26], iL[25]) != 0) { + break label_185; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((iL[22] + 2), 2) != 0) { + break label_180; + } + break label_181; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8, iL[22]) != 0) { + break label_180; + } + break label_182; + } + iL[23] = 9; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[26], iL[25]) != 0) { + break label_181; + } + } + memory.writeByte((int) iL[6] < 0 ? iL[6] : iL[6] + 88, (byte) (48)); + iL[20] = iL[13]; + break label_180; + } + iL[22] = (iL[23] + (iL[6] + 80)); + iL[20] = (iL[22] + -1); + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((iL[6] + 80), iL[20]) != 0 ? (iL[6] + 80) : iL[20]); + long[] callArgs_39 = new long[3]; + callArgs_39[2] = ((long) (iL[22] - iL[20])); + callArgs_39[1] = ((long) 48); + callArgs_39[0] = ((long) iL[20]); + long[] callResult_39 = instance.getMachine().call(1892, callArgs_39); + } + label_186: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_186; + } + long[] callArgs_40 = new long[3]; + callArgs_40[2] = ((long) iL[0]); + callArgs_40[1] = ((long) (iL[14] - iL[20])); + callArgs_40[0] = ((long) iL[20]); + long[] callResult_40 = instance.getMachine().call(1855, callArgs_40); + } + iL[25] = (iL[25] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[25], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_179; + } + break; + } + label_187: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[34]) != 0) { + break label_187; + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_187; + } + long[] callArgs_41 = new long[3]; + callArgs_41[2] = ((long) iL[0]); + callArgs_41[1] = ((long) 1); + callArgs_41[0] = ((long) 29323); + long[] callResult_41 = instance.getMachine().call(1855, callArgs_41); + } + label_188: { + label_189: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[25], iL[30]) != 0) { + break label_189; + } + iL[20] = iL[28]; + break label_188; + } + label_190: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[28], 1) != 0) { + break label_190; + } + iL[20] = iL[28]; + break label_188; + } + label_191: while (true) { + label_192: { + label_193: { + label_194: { + iL[20] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 0); + if (iL[20] != 0) { + break label_194; + } + iL[22] = iL[14]; + iL[23] = iL[14]; + break label_193; + } + iL[23] = iL[14]; + iL[22] = iL[14]; + label_195: while (true) { + iL[22] = (iL[22] + -1); + iL[21] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[20], 10); + memory.writeByte((int) iL[22] < 0 ? iL[22] : iL[22] + 0, (byte) (((iL[20] - (iL[21] * 10)) | 48))); + iL[23] = (iL[23] + -1); + iL[26] = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 9); + iL[20] = iL[21]; + if (iL[26] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_195; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[22], (iL[6] + 80)) != 0) { + break label_192; + } + } + iL[22] = ((iL[22] + (iL[6] + 80)) - iL[23]); + long[] callArgs_42 = new long[3]; + callArgs_42[2] = ((long) (iL[23] - (iL[6] + 80))); + callArgs_42[1] = ((long) 48); + callArgs_42[0] = ((long) iL[22]); + long[] callResult_42 = instance.getMachine().call(1892, callArgs_42); + } + label_196: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_196; + } + long[] callArgs_43 = new long[3]; + callArgs_43[2] = ((long) iL[0]); + callArgs_43[1] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[28], 9) != 0 ? iL[28] : 9)); + callArgs_43[0] = ((long) iL[22]); + long[] callResult_43 = instance.getMachine().call(1855, callArgs_43); + } + iL[20] = (iL[28] + -9); + iL[25] = (iL[25] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[25], iL[30]) != 0) { + break label_188; + } + iL[22] = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[28], 9); + iL[28] = iL[20]; + if (iL[22] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_191; + } + break; + } + } + long[] callArgs_44 = new long[5]; + callArgs_44[4] = ((long) 0); + callArgs_44[3] = ((long) 9); + callArgs_44[2] = ((long) (iL[20] + 9)); + callArgs_44[1] = ((long) 48); + callArgs_44[0] = ((long) iL[0]); + instance.getMachine().call(1873, callArgs_44); + { + _hs[0] = 8; + break _hb; + } + } + memory.writeI32((int) 658184 < 0 ? 658184 : 658184 + 0, (int) 28); + { + _hs[0] = 5; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1883__h0(int[] iL, long[] lL, double[] dL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_12: { + label_13: { + iL[11] = (iL[1] & -33); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(73, iL[11]) != 0) { + break label_13; + } + label_14: { + label_15: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_15; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_14; + } + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) iL[0]); + long[] callResult_2 = instance.getMachine().call(1880, callArgs_2); + iL[1] = ((int) callResult_2[0]); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(78, (iL[1] & -33)) != 0) { + break label_12; + } + label_16: { + label_17: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_17; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_16; + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) iL[0]); + long[] callResult_3 = instance.getMachine().call(1880, callArgs_3); + iL[1] = ((int) callResult_3[0]); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(70, (iL[1] & -33)) != 0) { + break label_12; + } + label_18: { + label_19: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_19; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[11] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_18; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) iL[0]); + long[] callResult_4 = instance.getMachine().call(1880, callArgs_4); + iL[11] = ((int) callResult_4[0]); + } + iL[1] = 3; + label_20: { + label_21: { + iL[11] = (iL[11] & -33); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(73, iL[11]) != 0) { + break label_21; + } + label_22: { + label_23: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_23; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[12] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_22; + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) iL[0]); + long[] callResult_5 = instance.getMachine().call(1880, callArgs_5); + iL[12] = ((int) callResult_5[0]); + } + iL[1] = 4; + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(78, (iL[12] & -33)) != 0) { + break label_24; + } + label_25: { + label_26: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_26; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[12] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_25; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) iL[0]); + long[] callResult_6 = instance.getMachine().call(1880, callArgs_6); + iL[12] = ((int) callResult_6[0]); + } + iL[1] = 5; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(73, (iL[12] & -33)) != 0) { + break label_24; + } + label_27: { + label_28: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_28; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[12] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_27; + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) iL[0]); + long[] callResult_7 = instance.getMachine().call(1880, callArgs_7); + iL[12] = ((int) callResult_7[0]); + } + iL[1] = 6; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(84, (iL[12] & -33)) != 0) { + break label_24; + } + label_29: { + label_30: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_30; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[12] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_29; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) iL[0]); + long[] callResult_8 = instance.getMachine().call(1880, callArgs_8); + iL[12] = ((int) callResult_8[0]); + } + iL[1] = 7; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(89, (iL[12] & -33)) != 0) { + break label_20; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_12; + } + } + label_31: { + lL[0] = memory.readLong((int) iL[0] < 0 ? iL[0] : iL[0] + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(lL[0], 0L) != 0) { + break label_31; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_20; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(73, iL[11]) != 0) { + break label_20; + } + label_32: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(lL[0], 0L) != 0) { + break label_32; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((iL[1] + -5), -5) != 0) { + break label_20; + } + label_33: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(lL[0], 0L) != 0) { + break label_33; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((iL[1] + -6), -5) != 0) { + break label_20; + } + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(lL[0], 0L) != 0) { + break label_34; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U((iL[1] + -7), -5) != 0) { + break label_20; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(lL[0], 0L) != 0) { + break label_20; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + dL[0] = (double) (com.dylibso.chicory.runtime.OpcodeImpl.F32_CONVERT_I32_S(iL[10]) * Float.POSITIVE_INFINITY); + { + _hs[0] = 1; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(78, iL[11]) != 0) { + break _hb; + } + label_35: { + label_36: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_36; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_35; + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) iL[0]); + long[] callResult_9 = instance.getMachine().call(1880, callArgs_9); + iL[1] = ((int) callResult_9[0]); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(65, (iL[1] & -33)) != 0) { + break label_12; + } + label_37: { + label_38: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_38; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_37; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) iL[0]); + long[] callResult_10 = instance.getMachine().call(1880, callArgs_10); + iL[1] = ((int) callResult_10[0]); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(78, (iL[1] & -33)) != 0) { + break label_12; + } + label_39: { + label_40: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_40; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_39; + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) iL[0]); + long[] callResult_11 = instance.getMachine().call(1880, callArgs_11); + iL[1] = ((int) callResult_11[0]); + } + label_41: { + label_42: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(40, iL[1]) != 0) { + break label_42; + } + iL[12] = 1; + iL[11] = 1; + break label_41; + } + dL[0] = Double.longBitsToDouble(9221120237041090560L); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(memory.readLong((int) iL[0] < 0 ? iL[0] : iL[0] + 88), 0L) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + { + _hs[0] = 1; + break _hb; + } + } + label_43: while (true) { + label_44: { + label_45: { + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84), iL[1]) != 0) { + break label_45; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (iL[1] + 1)); + iL[1] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 0) & 0xFF); + break label_44; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) iL[0]); + long[] callResult_12 = instance.getMachine().call(1880, callArgs_12); + iL[1] = ((int) callResult_12[0]); + } + iL[13] = (iL[1] + -65); + label_46: { + label_47: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((iL[1] + -48), 10) != 0) { + break label_47; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[13], 26) != 0) { + break label_47; + } + iL[13] = (iL[1] + -97); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(95, iL[1]) != 0) { + break label_47; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[13], 26) != 0) { + break label_46; + } + } + iL[12] = (iL[12] + 1); + iL[11] = (iL[11] + 1); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_43; + } + break; + } + label_48: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(41, iL[1]) != 0) { + break label_48; + } + dL[0] = Double.longBitsToDouble(9221120237041090560L); + { + _hs[0] = 1; + break _hb; + } + } + label_49: { + lL[0] = memory.readLong((int) iL[0] < 0 ? iL[0] : iL[0] + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(lL[0], 0L) != 0) { + break label_49; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + label_50: { + label_51: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_51; + } + label_52: { + if (iL[11] != 0) { + break label_52; + } + dL[0] = Double.longBitsToDouble(9221120237041090560L); + { + _hs[0] = 1; + break _hb; + } + } + iL[13] = (iL[11] + -1); + label_53: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[11] & 3)) != 0) { + break label_53; + } + iL[1] = (iL[12] & 3); + iL[0] = 0; + label_54: while (true) { + label_55: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(lL[0], 0L) != 0) { + break label_55; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + iL[0] = (iL[0] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[0], iL[1]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_54; + } + break; + } + iL[11] = (iL[11] - iL[0]); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[13], 3) != 0) { + break label_50; + } + dL[0] = Double.longBitsToDouble(9221120237041090560L); + { + _hs[0] = 1; + break _hb; + } + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 28); + long[] callArgs_13 = new long[2]; + callArgs_13[1] = 0L; + callArgs_13[0] = ((long) iL[0]); + instance.getMachine().call(1879, callArgs_13); + { + _hs[0] = 1; + break _hb; + } + } + iL[0] = com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(lL[0], 0L); + label_56: while (true) { + label_57: { + if (iL[0] != 0) { + break label_57; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -3)); + } + iL[11] = (iL[11] + -4); + label_58: { + if (iL[0] != 0) { + break label_58; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + if (iL[11] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_56; + } + break; + } + dL[0] = Double.longBitsToDouble(9221120237041090560L); + { + _hs[0] = 1; + break _hb; + } + } + label_59: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_S(memory.readLong((int) iL[0] < 0 ? iL[0] : iL[0] + 88), 0L) != 0) { + break label_59; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) (memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0) + -1)); + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658184, (int) 28); + long[] callArgs_14 = new long[2]; + callArgs_14[1] = 0L; + callArgs_14[0] = ((long) iL[0]); + instance.getMachine().call(1879, callArgs_14); + { + _hs[0] = 1; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_41__h1(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) < 0 ? memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) : memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 20) & 0xFF)) != 0) { + break _hb; + } + iL[25] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[26] = ((iL[23] + 560) | 4); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) iL[26]); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 564, (long) 0L); + iL[27] = ((iL[23] + 384) | 4); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 384, (int) iL[27]); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 388, (long) 0L); + iL[28] = ((iL[23] + 536) | 4); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 536, (int) iL[28]); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 540, (long) 0L); + iL[29] = ((iL[23] + 520) | 4); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 520, (int) iL[29]); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 524, (long) 0L); + label_4: { + iL[30] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 112); + iL[31] = memory.readInt((int) (iL[25] + 116) < 0 ? (iL[25] + 116) : (iL[25] + 116) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[31], iL[30]) != 0) { + break label_4; + } + iL[32] = ((iL[23] + 520) + 8); + iL[33] = ((iL[23] + 536) + 8); + iL[34] = ((iL[23] + 384) + 8); + iL[35] = ((iL[23] + 560) + 8); + label_5: while (true) { + label_6: { + label_7: { + label_8: { + label_9: { + label_10: { + label_11: { + label_12: { + iL[24] = memory.readInt((int) iL[30] < 0 ? iL[30] : iL[30] + 0); + switch(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 12)) { + case 0: + { + break label_12; + } + case 1: + { + break label_11; + } + case 2: + { + break label_6; + } + case 3: + { + break label_10; + } + case 4: + { + break label_9; + } + default: + { + break label_6; + } + } + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) (iL[24] + 16)); + callArgs_2[0] = ((long) iL[25]); + long[] callResult_2 = instance.getMachine().call(121, callArgs_2); + iL[36] = ((int) callResult_2[0]); + iL[24] = iL[26]; + iL[37] = iL[26]; + label_13: { + iL[38] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 564); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_13; + } + label_14: while (true) { + label_15: { + iL[37] = iL[38]; + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[36], iL[24]) != 0) { + break label_15; + } + iL[24] = iL[37]; + iL[38] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + if (iL[38] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break label_13; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[24], iL[36]) != 0) { + break label_6; + } + iL[38] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + if (iL[38] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + break; + } + iL[24] = (iL[37] + 4); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) 20); + long[] callResult_3 = instance.getMachine().call(1776, callArgs_3); + iL[38] = ((int) callResult_3[0]); + memory.writeI32((int) iL[38] < 0 ? iL[38] : iL[38] + 8, (int) iL[37]); + memory.writeLong((int) iL[38] < 0 ? iL[38] : iL[38] + 0, (long) 0L); + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 0, (int) iL[38]); + memory.writeI32((int) iL[38] < 0 ? iL[38] : iL[38] + 16, (int) iL[36]); + iL[36] = iL[26]; + iL[37] = iL[35]; + iL[39] = memory.readInt((int) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) < 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) : memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[39]) != 0) { + break label_7; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) iL[39]); + iL[36] = iL[26]; + iL[37] = iL[35]; + break label_8; + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) (iL[24] + 16)); + callArgs_4[0] = ((long) iL[25]); + long[] callResult_4 = instance.getMachine().call(123, callArgs_4); + iL[36] = ((int) callResult_4[0]); + iL[24] = iL[29]; + iL[37] = iL[29]; + label_16: { + iL[38] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 524); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_16; + } + label_17: while (true) { + label_18: { + iL[37] = iL[38]; + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[36], iL[24]) != 0) { + break label_18; + } + iL[24] = iL[37]; + iL[38] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + if (iL[38] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_17; + } + break label_16; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[24], iL[36]) != 0) { + break label_6; + } + iL[38] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + if (iL[38] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_17; + } + break; + } + iL[24] = (iL[37] + 4); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) 20); + long[] callResult_5 = instance.getMachine().call(1776, callArgs_5); + iL[38] = ((int) callResult_5[0]); + memory.writeI32((int) iL[38] < 0 ? iL[38] : iL[38] + 8, (int) iL[37]); + memory.writeLong((int) iL[38] < 0 ? iL[38] : iL[38] + 0, (long) 0L); + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 0, (int) iL[38]); + memory.writeI32((int) iL[38] < 0 ? iL[38] : iL[38] + 16, (int) iL[36]); + iL[36] = iL[29]; + iL[37] = iL[32]; + iL[39] = memory.readInt((int) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 520) < 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 520) : memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 520) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[39]) != 0) { + break label_7; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 520, (int) iL[39]); + iL[36] = iL[29]; + iL[37] = iL[32]; + break label_8; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) (iL[24] + 16)); + callArgs_6[0] = ((long) iL[25]); + long[] callResult_6 = instance.getMachine().call(122, callArgs_6); + iL[36] = ((int) callResult_6[0]); + iL[24] = iL[27]; + iL[37] = iL[27]; + label_19: { + iL[38] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 388); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_19; + } + label_20: while (true) { + label_21: { + iL[37] = iL[38]; + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[36], iL[24]) != 0) { + break label_21; + } + iL[24] = iL[37]; + iL[38] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + if (iL[38] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break label_19; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[24], iL[36]) != 0) { + break label_6; + } + iL[38] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + if (iL[38] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_20; + } + break; + } + iL[24] = (iL[37] + 4); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) 20); + long[] callResult_7 = instance.getMachine().call(1776, callArgs_7); + iL[38] = ((int) callResult_7[0]); + memory.writeI32((int) iL[38] < 0 ? iL[38] : iL[38] + 8, (int) iL[37]); + memory.writeLong((int) iL[38] < 0 ? iL[38] : iL[38] + 0, (long) 0L); + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 0, (int) iL[38]); + memory.writeI32((int) iL[38] < 0 ? iL[38] : iL[38] + 16, (int) iL[36]); + iL[36] = iL[27]; + iL[37] = iL[34]; + iL[39] = memory.readInt((int) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 384) < 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 384) : memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 384) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[39]) != 0) { + break label_7; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 384, (int) iL[39]); + iL[36] = iL[27]; + iL[37] = iL[34]; + break label_8; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) (iL[24] + 16)); + callArgs_8[0] = ((long) iL[25]); + long[] callResult_8 = instance.getMachine().call(126, callArgs_8); + iL[36] = ((int) callResult_8[0]); + iL[24] = iL[28]; + iL[37] = iL[28]; + label_22: { + iL[38] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 540); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_22; + } + label_23: while (true) { + label_24: { + iL[37] = iL[38]; + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[36], iL[24]) != 0) { + break label_24; + } + iL[24] = iL[37]; + iL[38] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + if (iL[38] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break label_22; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[24], iL[36]) != 0) { + break label_6; + } + iL[38] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + if (iL[38] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break; + } + iL[24] = (iL[37] + 4); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) 20); + long[] callResult_9 = instance.getMachine().call(1776, callArgs_9); + iL[38] = ((int) callResult_9[0]); + memory.writeI32((int) iL[38] < 0 ? iL[38] : iL[38] + 8, (int) iL[37]); + memory.writeLong((int) iL[38] < 0 ? iL[38] : iL[38] + 0, (long) 0L); + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 0, (int) iL[38]); + memory.writeI32((int) iL[38] < 0 ? iL[38] : iL[38] + 16, (int) iL[36]); + iL[36] = iL[28]; + iL[37] = iL[33]; + iL[39] = memory.readInt((int) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 536) < 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 536) : memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 536) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[39]) != 0) { + break label_7; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 536, (int) iL[39]); + iL[36] = iL[28]; + iL[37] = iL[33]; + } + iL[38] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) iL[38]); + callArgs_10[0] = ((long) memory.readInt((int) iL[36] < 0 ? iL[36] : iL[36] + 0)); + instance.getMachine().call(43, callArgs_10); + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (int) (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0) + 1)); + } + iL[30] = (iL[30] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[31], iL[30]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_5; + } + break; + } + } + iL[26] = (iL[0] + 12); + label_25: { + label_26: { + label_27: { + label_28: { + int _d3 = func_41__h3(iL, lL, memory, instance); + if (_d3 == 1) + break label_26; + if (_d3 == 2) + break label_27; + if (_d3 == 3) + break label_25; + if (_d3 >= 10000) { + _hs[0] = (_d3 - 10000); + break _hb; + } + } + instance.getMachine().call(45, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + instance.getMachine().call(46, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + iL[37] = 1; + } + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 524)); + callArgs_28[0] = ((long) (iL[23] + 520)); + instance.getMachine().call(34, callArgs_28); + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 540)); + callArgs_29[0] = ((long) (iL[23] + 536)); + instance.getMachine().call(34, callArgs_29); + long[] callArgs_30 = new long[2]; + callArgs_30[1] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 388)); + callArgs_30[0] = ((long) (iL[23] + 384)); + instance.getMachine().call(34, callArgs_30); + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 564)); + callArgs_31[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(34, callArgs_31); + iL[24] = 1; + if (iL[37] != 0) { + { + _hs[0] = 2; + break _hb; + } + } + } while (false); + return _hs[0]; + } + + private static int func_51__h1(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_12: { + label_13: { + label_14: { + label_15: { + label_16: { + label_17: { + label_18: { + label_19: { + label_20: { + label_21: { + label_22: { + label_23: { + label_24: { + int _d0 = func_51__h0(iL, lL, memory, instance); + if (_d0 == 1) { + _hs[0] = 1; + break _hb; + } + if (_d0 == 2) + break label_20; + if (_d0 == 3) + break label_21; + if (_d0 == 4) + break label_23; + if (_d0 == 5) + break label_22; + if (_d0 == 6) + break label_19; + if (_d0 == 7) + break label_18; + if (_d0 == 8) + break label_17; + if (_d0 == 9) { + _hs[0] = 2; + break _hb; + } + if (_d0 == 10) { + _hs[0] = 3; + break _hb; + } + if (_d0 == 11) { + _hs[0] = 4; + break _hb; + } + if (_d0 == 12) { + _hs[0] = 5; + break _hb; + } + if (_d0 == 13) { + _hs[0] = 6; + break _hb; + } + if (_d0 == 14) { + _hs[0] = 7; + break _hb; + } + if (_d0 == 15) + break label_16; + if (_d0 == 16) { + _hs[0] = 8; + break _hb; + } + if (_d0 == 17) + break label_15; + if (_d0 == 18) + break label_14; + if (_d0 == 19) + break label_13; + if (_d0 == 20) + break label_12; + if (_d0 == 21) + break _hb; + if (_d0 == 22) { + _hs[0] = 9; + break _hb; + } + if (_d0 == 23) { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_124 = new long[2]; + callArgs_124[1] = ((long) (iL[2] + 36)); + callArgs_124[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_124 = instance.getMachine().call(123, callArgs_124); + iL[2] = ((int) callResult_124[0]); + long[] callArgs_125 = new long[2]; + callArgs_125[1] = ((long) 215); + callArgs_125[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_125); + long[] callArgs_126 = new long[3]; + callArgs_126[2] = ((long) 2063); + callArgs_126[1] = ((long) iL[2]); + callArgs_126[0] = ((long) iL[0]); + instance.getMachine().call(64, callArgs_126); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_127 = new long[2]; + callArgs_127[1] = ((long) 218); + callArgs_127[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_127); + long[] callArgs_128 = new long[2]; + callArgs_128[1] = ((long) (iL[2] + 36)); + callArgs_128[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_128 = instance.getMachine().call(121, callArgs_128); + long[] callArgs_129 = new long[4]; + callArgs_129[3] = ((long) 0); + callArgs_129[2] = ((long) 1564); + callArgs_129[1] = ((long) ((int) callResult_128[0])); + callArgs_129[0] = ((long) iL[0]); + instance.getMachine().call(63, callArgs_129); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_130 = new long[2]; + callArgs_130[1] = ((long) 216); + callArgs_130[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_130); + lL[0] = memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 36); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 8, (long) lL[0]); + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (long) lL[0]); + long[] callArgs_131 = new long[3]; + callArgs_131[2] = ((long) 15936); + callArgs_131[1] = ((long) iL[3]); + callArgs_131[0] = ((long) iL[0]); + instance.getMachine().call(37, callArgs_131); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_132 = new long[2]; + callArgs_132[1] = ((long) 217); + callArgs_132[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_132); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_133 = new long[2]; + callArgs_133[1] = ((long) 1); + callArgs_133[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_133); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_134 = new long[2]; + callArgs_134[1] = ((long) 9); + callArgs_134[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_134); + long[] callArgs_135 = new long[3]; + callArgs_135[2] = ((long) 14061); + callArgs_135[1] = ((long) memory.readInt((int) (iL[2] + 60) < 0 ? (iL[2] + 60) : (iL[2] + 60) + 0)); + callArgs_135[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_135); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_136 = new long[2]; + callArgs_136[1] = ((long) 15); + callArgs_136[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_136); + { + _hs[0] = 10; + break _hb; + } + } + iL[1] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + label_81: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) (iL[2] + 40) < 0 ? (iL[2] + 40) : (iL[2] + 40) + 0), memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)) != 0) { + break label_81; + } + long[] callArgs_137 = new long[2]; + callArgs_137[1] = ((long) 24); + callArgs_137[0] = ((long) iL[1]); + instance.getMachine().call(36, callArgs_137); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_138 = new long[2]; + callArgs_138[1] = ((long) 25); + callArgs_138[0] = ((long) iL[1]); + instance.getMachine().call(36, callArgs_138); + long[] callArgs_139 = new long[3]; + callArgs_139[2] = ((long) 8481); + callArgs_139[1] = ((long) ((memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 40) - memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)) >> 3)); + callArgs_139[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_139); + iL[1] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36); + iL[5] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[5], iL[1]) != 0) { + { + _hs[0] = 10; + break _hb; + } + } + label_82: while (true) { + iL[4] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + lL[0] = memory.readLong((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[2] = (int) lL[0]; + long[] callArgs_140 = new long[3]; + callArgs_140[2] = ((long) 15804); + callArgs_140[1] = ((long) iL[2]); + callArgs_140[0] = ((long) iL[4]); + instance.getMachine().call(173, callArgs_140); + label_83: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, iL[2]) != 0) { + break label_83; + } + long[] callArgs_141 = new long[3]; + callArgs_141[2] = ((long) 15804); + callArgs_141[1] = ((long) (int) (lL[0] >>> 32L)); + callArgs_141[0] = ((long) iL[4]); + instance.getMachine().call(173, callArgs_141); + } + iL[1] = (iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[5], iL[1]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_82; + } + { + _hs[0] = 10; + break _hb; + } + } + } + long[] callArgs_142 = new long[2]; + callArgs_142[1] = ((long) iL[2]); + callArgs_142[0] = ((long) iL[0]); + instance.getMachine().call(66, callArgs_142); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_143 = new long[2]; + callArgs_143[1] = ((long) 8); + callArgs_143[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_143); + long[] callArgs_144 = new long[3]; + callArgs_144[2] = ((long) 14694); + callArgs_144[1] = ((long) memory.readInt((int) (iL[2] + 60) < 0 ? (iL[2] + 60) : (iL[2] + 60) + 0)); + callArgs_144[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_144); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_145 = new long[2]; + callArgs_145[1] = ((long) 10); + callArgs_145[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_145); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_146 = new long[2]; + callArgs_146[1] = ((long) 6); + callArgs_146[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_146); + long[] callArgs_147 = new long[2]; + callArgs_147[1] = ((long) (iL[2] + 52)); + callArgs_147[0] = ((long) iL[0]); + instance.getMachine().call(62, callArgs_147); + long[] callArgs_148 = new long[3]; + callArgs_148[2] = ((long) (iL[2] + 156)); + callArgs_148[1] = ((long) iL[1]); + callArgs_148[0] = ((long) iL[0]); + instance.getMachine().call(55, callArgs_148); + label_84: { + label_85: { + label_86: { + switch(memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)) { + case 0: + { + break label_84; + } + case 1: + { + break label_86; + } + case 2: + { + break label_85; + } + default: + { + { + _hs[0] = 10; + break _hb; + } + } + } + } + label_87: { + iL[4] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 188); + iL[6] = memory.readInt((int) (iL[2] + 192) < 0 ? (iL[2] + 192) : (iL[2] + 192) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[6], iL[4]) != 0) { + break label_87; + } + label_88: while (true) { + iL[2] = (iL[4] + 44); + iL[5] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + label_89: { + label_90: { + if (memory.readInt((int) (iL[4] + 40) < 0 ? (iL[4] + 40) : (iL[4] + 40) + 0) != 0) { + break label_90; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 0)) != 0) { + break label_90; + } + long[] callArgs_149 = new long[2]; + callArgs_149[1] = ((long) 22); + callArgs_149[0] = ((long) iL[5]); + instance.getMachine().call(36, callArgs_149); + break label_89; + } + long[] callArgs_150 = new long[2]; + callArgs_150[1] = ((long) 7); + callArgs_150[0] = ((long) iL[5]); + instance.getMachine().call(36, callArgs_150); + long[] callArgs_151 = new long[3]; + callArgs_151[2] = ((long) 14704); + callArgs_151[1] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 0)); + callArgs_151[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_151); + } + label_91: { + iL[2] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[2]) != 0) { + break label_91; + } + label_92: while (true) { + long[] callArgs_152 = new long[3]; + callArgs_152[2] = ((long) iL[2]); + callArgs_152[1] = ((long) iL[1]); + callArgs_152[0] = ((long) iL[0]); + instance.getMachine().call(51, callArgs_152); + iL[2] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 4); + if (iL[2] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_92; + } + break; + } + } + iL[4] = (iL[4] + 68); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[6], iL[4]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_88; + } + break; + } + } + long[] callArgs_153 = new long[2]; + callArgs_153[1] = ((long) 11); + callArgs_153[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_153); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_154 = new long[2]; + callArgs_154[1] = ((long) 21); + callArgs_154[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_154); + long[] callArgs_155 = new long[3]; + callArgs_155[2] = ((long) 14210); + callArgs_155[1] = ((long) memory.readInt((int) (iL[2] + 224) < 0 ? (iL[2] + 224) : (iL[2] + 224) + 0)); + callArgs_155[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_155); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_156 = new long[2]; + callArgs_156[1] = ((long) 11); + callArgs_156[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_156); + { + _hs[0] = 10; + break _hb; + } + } + long[] callArgs_157 = new long[2]; + callArgs_157[1] = ((long) 26); + callArgs_157[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_157); + long[] callArgs_158 = new long[2]; + callArgs_158[1] = ((long) (iL[2] + 48)); + callArgs_158[0] = ((long) iL[0]); + instance.getMachine().call(62, callArgs_158); + iL[5] = (iL[2] + 188); + long[] callArgs_159 = new long[3]; + callArgs_159[2] = ((long) 8661); + callArgs_159[1] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) - memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 184)), 96)); + callArgs_159[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_159); + label_93: { + iL[4] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 184); + iL[7] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[7], iL[4]) != 0) { + break label_93; + } + label_94: while (true) { + iL[5] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[6] = (iL[4] + 92); + iL[8] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (byte) (((com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(2, (iL[8] & -2)) << 1) | com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, (iL[8] & -3))))); + long[] callArgs_160 = new long[5]; + callArgs_160[4] = ((long) 0); + callArgs_160[3] = ((long) 11591); + callArgs_160[2] = ((long) 1); + callArgs_160[1] = ((long) (iL[3] + 16)); + callArgs_160[0] = ((long) iL[5]); + instance.getMachine().call(224, callArgs_160); + label_95: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(2, (memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0) & -2)) != 0) { + break label_95; + } + long[] callArgs_161 = new long[3]; + callArgs_161[2] = ((long) 14704); + callArgs_161[1] = ((long) memory.readInt((int) (iL[4] + 44) < 0 ? (iL[4] + 44) : (iL[4] + 44) + 0)); + callArgs_161[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_161); + } + long[] callArgs_162 = new long[3]; + callArgs_162[2] = ((long) 14148); + callArgs_162[1] = ((long) memory.readInt((int) (iL[4] + 80) < 0 ? (iL[4] + 80) : (iL[4] + 80) + 0)); + callArgs_162[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_162); + iL[4] = (iL[4] + 96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[7], iL[4]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_94; + } + break; + } + } + long[] callArgs_163 = new long[3]; + callArgs_163[2] = ((long) (iL[2] + 152)); + callArgs_163[1] = ((long) iL[1]); + callArgs_163[0] = ((long) iL[0]); + instance.getMachine().call(55, callArgs_163); + long[] callArgs_164 = new long[2]; + callArgs_164[1] = ((long) 11); + callArgs_164[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_164); + { + _hs[0] = 10; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_450__h1(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_12: { + label_13: { + label_14: { + label_15: { + label_16: { + label_17: { + label_18: { + label_19: { + label_20: { + label_21: { + label_22: { + label_23: { + label_24: { + label_25: { + label_26: { + int _d0 = func_450__h0(iL, memory, instance); + if (_d0 == 1) + break label_20; + if (_d0 == 2) + break label_21; + if (_d0 == 3) + break label_23; + if (_d0 == 4) + break label_22; + if (_d0 == 5) + break label_19; + if (_d0 == 6) + break label_18; + if (_d0 == 7) + break label_17; + if (_d0 == 8) + break label_16; + if (_d0 == 9) + break label_15; + if (_d0 == 10) { + _hs[0] = 1; + break _hb; + } + if (_d0 == 11) { + _hs[0] = 2; + break _hb; + } + if (_d0 == 12) { + _hs[0] = 3; + break _hb; + } + if (_d0 == 13) { + _hs[0] = 4; + break _hb; + } + if (_d0 == 14) + break label_14; + if (_d0 == 15) + break label_25; + if (_d0 == 16) + break label_24; + if (_d0 == 17) { + _hs[0] = 5; + break _hb; + } + if (_d0 == 18) + break label_13; + if (_d0 == 19) + break label_12; + if (_d0 == 20) { + _hs[0] = 6; + break _hb; + } + if (_d0 == 21) + break _hb; + if (_d0 == 22) { + _hs[0] = 7; + break _hb; + } + if (_d0 == 23) { + _hs[0] = 8; + break _hb; + } + if (_d0 == 24) { + _hs[0] = 9; + break _hb; + } + if (_d0 == 25) { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_44 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 160)); + int ciFuncId_44 = instance.table(0).requiredRef(ciTableIdx_44); + com.dylibso.chicory.runtime.Instance ciRefInstance_44 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_44), instance); + if (!ciRefInstance_44.type(ciRefInstance_44.functionType(ciFuncId_44)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_44 = new long[2]; + callArgs_44[1] = ((long) iL[1]); + callArgs_44[0] = ((long) iL[0]); + long[] callResult_44 = ciRefInstance_44.getMachine().call(ciFuncId_44, callArgs_44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_44[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_45 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 164)); + int ciFuncId_45 = instance.table(0).requiredRef(ciTableIdx_45); + com.dylibso.chicory.runtime.Instance ciRefInstance_45 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_45), instance); + if (!ciRefInstance_45.type(ciRefInstance_45.functionType(ciFuncId_45)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_45 = new long[2]; + callArgs_45[1] = ((long) iL[1]); + callArgs_45[0] = ((long) iL[0]); + long[] callResult_45 = ciRefInstance_45.getMachine().call(ciFuncId_45, callArgs_45); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_45[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_46 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 168)); + int ciFuncId_46 = instance.table(0).requiredRef(ciTableIdx_46); + com.dylibso.chicory.runtime.Instance ciRefInstance_46 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_46), instance); + if (!ciRefInstance_46.type(ciRefInstance_46.functionType(ciFuncId_46)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_46 = new long[2]; + callArgs_46[1] = ((long) iL[1]); + callArgs_46[0] = ((long) iL[0]); + long[] callResult_46 = ciRefInstance_46.getMachine().call(ciFuncId_46, callArgs_46); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_46[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_47 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 172)); + int ciFuncId_47 = instance.table(0).requiredRef(ciTableIdx_47); + com.dylibso.chicory.runtime.Instance ciRefInstance_47 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_47), instance); + if (!ciRefInstance_47.type(ciRefInstance_47.functionType(ciFuncId_47)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_47 = new long[2]; + callArgs_47[1] = ((long) iL[1]); + callArgs_47[0] = ((long) iL[0]); + long[] callResult_47 = ciRefInstance_47.getMachine().call(ciFuncId_47, callArgs_47); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_47[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_48 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 176)); + int ciFuncId_48 = instance.table(0).requiredRef(ciTableIdx_48); + com.dylibso.chicory.runtime.Instance ciRefInstance_48 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_48), instance); + if (!ciRefInstance_48.type(ciRefInstance_48.functionType(ciFuncId_48)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_48 = new long[2]; + callArgs_48[1] = ((long) iL[1]); + callArgs_48[0] = ((long) iL[0]); + long[] callResult_48 = ciRefInstance_48.getMachine().call(ciFuncId_48, callArgs_48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_48[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_49 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 180)); + int ciFuncId_49 = instance.table(0).requiredRef(ciTableIdx_49); + com.dylibso.chicory.runtime.Instance ciRefInstance_49 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_49), instance); + if (!ciRefInstance_49.type(ciRefInstance_49.functionType(ciFuncId_49)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_49 = new long[2]; + callArgs_49[1] = ((long) iL[1]); + callArgs_49[0] = ((long) iL[0]); + long[] callResult_49 = ciRefInstance_49.getMachine().call(ciFuncId_49, callArgs_49); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_49[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_50 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 184)); + int ciFuncId_50 = instance.table(0).requiredRef(ciTableIdx_50); + com.dylibso.chicory.runtime.Instance ciRefInstance_50 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_50), instance); + if (!ciRefInstance_50.type(ciRefInstance_50.functionType(ciFuncId_50)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_50 = new long[2]; + callArgs_50[1] = ((long) iL[1]); + callArgs_50[0] = ((long) iL[0]); + long[] callResult_50 = ciRefInstance_50.getMachine().call(ciFuncId_50, callArgs_50); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_50[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_51 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 240)); + int ciFuncId_51 = instance.table(0).requiredRef(ciTableIdx_51); + com.dylibso.chicory.runtime.Instance ciRefInstance_51 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_51), instance); + if (!ciRefInstance_51.type(ciRefInstance_51.functionType(ciFuncId_51)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_51 = new long[2]; + callArgs_51[1] = ((long) iL[1]); + callArgs_51[0] = ((long) iL[0]); + long[] callResult_51 = ciRefInstance_51.getMachine().call(ciFuncId_51, callArgs_51); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_51[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_52 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 188)); + int ciFuncId_52 = instance.table(0).requiredRef(ciTableIdx_52); + com.dylibso.chicory.runtime.Instance ciRefInstance_52 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_52), instance); + if (!ciRefInstance_52.type(ciRefInstance_52.functionType(ciFuncId_52)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_52 = new long[2]; + callArgs_52[1] = ((long) iL[1]); + callArgs_52[0] = ((long) iL[0]); + long[] callResult_52 = ciRefInstance_52.getMachine().call(ciFuncId_52, callArgs_52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_52[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_53 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 192)); + int ciFuncId_53 = instance.table(0).requiredRef(ciTableIdx_53); + com.dylibso.chicory.runtime.Instance ciRefInstance_53 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_53), instance); + if (!ciRefInstance_53.type(ciRefInstance_53.functionType(ciFuncId_53)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_53 = new long[2]; + callArgs_53[1] = ((long) iL[1]); + callArgs_53[0] = ((long) iL[0]); + long[] callResult_53 = ciRefInstance_53.getMachine().call(ciFuncId_53, callArgs_53); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_53[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_54 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 196)); + int ciFuncId_54 = instance.table(0).requiredRef(ciTableIdx_54); + com.dylibso.chicory.runtime.Instance ciRefInstance_54 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_54), instance); + if (!ciRefInstance_54.type(ciRefInstance_54.functionType(ciFuncId_54)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_54 = new long[2]; + callArgs_54[1] = ((long) iL[1]); + callArgs_54[0] = ((long) iL[0]); + long[] callResult_54 = ciRefInstance_54.getMachine().call(ciFuncId_54, callArgs_54); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_54[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_55 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 200)); + int ciFuncId_55 = instance.table(0).requiredRef(ciTableIdx_55); + com.dylibso.chicory.runtime.Instance ciRefInstance_55 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_55), instance); + if (!ciRefInstance_55.type(ciRefInstance_55.functionType(ciFuncId_55)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_55 = new long[2]; + callArgs_55[1] = ((long) iL[1]); + callArgs_55[0] = ((long) iL[0]); + long[] callResult_55 = ciRefInstance_55.getMachine().call(ciFuncId_55, callArgs_55); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_55[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_56 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 204)); + int ciFuncId_56 = instance.table(0).requiredRef(ciTableIdx_56); + com.dylibso.chicory.runtime.Instance ciRefInstance_56 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_56), instance); + if (!ciRefInstance_56.type(ciRefInstance_56.functionType(ciFuncId_56)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_56 = new long[2]; + callArgs_56[1] = ((long) iL[1]); + callArgs_56[0] = ((long) iL[0]); + long[] callResult_56 = ciRefInstance_56.getMachine().call(ciFuncId_56, callArgs_56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_56[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_57 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 232)); + int ciFuncId_57 = instance.table(0).requiredRef(ciTableIdx_57); + com.dylibso.chicory.runtime.Instance ciRefInstance_57 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_57), instance); + if (!ciRefInstance_57.type(ciRefInstance_57.functionType(ciFuncId_57)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_57 = new long[2]; + callArgs_57[1] = ((long) iL[1]); + callArgs_57[0] = ((long) iL[0]); + long[] callResult_57 = ciRefInstance_57.getMachine().call(ciFuncId_57, callArgs_57); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_57[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_58 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 236)); + int ciFuncId_58 = instance.table(0).requiredRef(ciTableIdx_58); + com.dylibso.chicory.runtime.Instance ciRefInstance_58 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_58), instance); + if (!ciRefInstance_58.type(ciRefInstance_58.functionType(ciFuncId_58)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_58 = new long[2]; + callArgs_58[1] = ((long) iL[1]); + callArgs_58[0] = ((long) iL[0]); + long[] callResult_58 = ciRefInstance_58.getMachine().call(ciFuncId_58, callArgs_58); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_58[0])) != 0) { + { + _hs[0] = 9; + break _hb; + } + } + { + _hs[0] = 10; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h1(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_28: { + label_29: { + label_30: { + label_31: { + label_32: { + label_33: { + label_34: { + label_35: { + label_36: { + label_37: { + int _d4 = func_801__h4(iL, lL, memory, instance); + if (_d4 == 1) + break label_29; + if (_d4 == 2) + break label_31; + if (_d4 == 3) + break label_32; + if (_d4 == 4) + break label_36; + if (_d4 == 5) + break label_33; + if (_d4 == 6) + break label_28; + if (_d4 == 7) + break label_35; + if (_d4 == 8) + break label_34; + if (_d4 >= 10000) { + _hs[0] = (_d4 - 10000); + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)); + } + label_533: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_609 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 32)); + int ciFuncId_609 = instance.table(0).requiredRef(ciTableIdx_609); + com.dylibso.chicory.runtime.Instance ciRefInstance_609 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_609), instance); + if (!ciRefInstance_609.type(ciRefInstance_609.functionType(ciFuncId_609)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_609 = new long[1]; + callArgs_609[0] = ((long) iL[3]); + long[] callResult_609 = ciRefInstance_609.getMachine().call(ciFuncId_609, callArgs_609); + if (((int) callResult_609[0]) != 0) { + break label_533; + } + iL[3] = 0; + break label_30; + } + long[] callArgs_610 = new long[3]; + callArgs_610[2] = ((long) 0); + callArgs_610[1] = ((long) 23825); + callArgs_610[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_610); + break label_31; + } + long[] callArgs_611 = new long[3]; + callArgs_611[2] = ((long) 0); + callArgs_611[1] = ((long) 19745); + callArgs_611[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_611); + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + break label_31; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + break label_31; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + } + iL[3] = 1; + } + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 3045, (byte) (iL[14])); + } + label_534: { + if (((int) memory.read((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) + 26) & 0xFF) != 0) { + break label_534; + } + iL[12] = 0; + iL[3] = iL[3]; + break label_28; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(0, iL[3])); + iL[3] = iL[3]; + } + label_535: { + label_536: { + switch(iL[3]) { + case 0: + { + break label_536; + } + case 1: + { + break label_535; + } + default: + { + { + _hs[0] = 3; + break _hb; + } + } + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948)) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 112, (int) iL[3]); + long[] callArgs_612 = new long[3]; + callArgs_612[2] = ((long) (iL[4] + 112)); + callArgs_612[1] = ((long) 29381); + callArgs_612[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_612); + iL[7] = 1; + } + if (iL[12] != 0) { + { + _hs[0] = 1; + break _hb; + } + } + } while (false); + return _hs[0]; + } + + private static int func_804__h1(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_26: { + label_27: { + label_28: { + label_29: { + label_30: { + label_31: { + label_32: { + label_33: { + label_34: { + label_35: { + label_36: { + label_37: { + label_38: { + label_39: { + label_40: { + label_41: { + int _d4 = func_804__h4(iL, lL, memory, instance); + if (_d4 == 1) + break label_26; + if (_d4 == 2) + break label_27; + if (_d4 == 3) + break label_28; + if (_d4 == 4) + break label_29; + if (_d4 == 5) + break label_30; + if (_d4 == 6) + break label_31; + if (_d4 == 7) + break label_32; + if (_d4 == 8) + break label_33; + if (_d4 == 9) + break label_34; + if (_d4 == 10) + break label_35; + if (_d4 == 11) + break label_36; + if (_d4 == 12) + break label_37; + if (_d4 == 13) + break label_38; + if (_d4 == 14) + break label_39; + if (_d4 == 15) + break label_40; + if (_d4 >= 10000) { + _hs[0] = (_d4 - 10000); + break _hb; + } + } + long[] callArgs_339 = new long[3]; + callArgs_339[2] = ((long) 0); + callArgs_339[1] = ((long) iL[4]); + callArgs_339[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_339); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_340 = new long[3]; + callArgs_340[2] = ((long) 0); + callArgs_340[1] = ((long) iL[4]); + callArgs_340[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_340); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_341 = new long[3]; + callArgs_341[2] = ((long) 0); + callArgs_341[1] = ((long) iL[4]); + callArgs_341[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_341); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_342 = new long[3]; + callArgs_342[2] = ((long) 0); + callArgs_342[1] = ((long) iL[4]); + callArgs_342[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_342); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_343 = new long[3]; + callArgs_343[2] = ((long) 0); + callArgs_343[1] = ((long) iL[4]); + callArgs_343[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_343); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_344 = new long[3]; + callArgs_344[2] = ((long) 0); + callArgs_344[1] = ((long) iL[4]); + callArgs_344[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_344); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_345 = new long[3]; + callArgs_345[2] = ((long) 0); + callArgs_345[1] = ((long) iL[4]); + callArgs_345[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_345); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_346 = new long[3]; + callArgs_346[2] = ((long) 0); + callArgs_346[1] = ((long) iL[4]); + callArgs_346[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_346); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_347 = new long[3]; + callArgs_347[2] = ((long) 0); + callArgs_347[1] = ((long) iL[4]); + callArgs_347[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_347); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_348 = new long[3]; + callArgs_348[2] = ((long) 0); + callArgs_348[1] = ((long) iL[4]); + callArgs_348[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_348); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_349 = new long[3]; + callArgs_349[2] = ((long) 0); + callArgs_349[1] = ((long) iL[4]); + callArgs_349[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_349); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_350 = new long[3]; + callArgs_350[2] = ((long) 0); + callArgs_350[1] = ((long) iL[4]); + callArgs_350[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_350); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_351 = new long[3]; + callArgs_351[2] = ((long) 0); + callArgs_351[1] = ((long) iL[4]); + callArgs_351[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_351); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_352 = new long[3]; + callArgs_352[2] = ((long) 0); + callArgs_352[1] = ((long) iL[4]); + callArgs_352[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_352); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_353 = new long[3]; + callArgs_353[2] = ((long) 0); + callArgs_353[1] = ((long) iL[4]); + callArgs_353[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_353); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_354 = new long[3]; + callArgs_354[2] = ((long) 0); + callArgs_354[1] = ((long) iL[4]); + callArgs_354[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_354); + { + _hs[0] = 1; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1176__h1(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_13: { + label_14: { + label_15: { + label_16: { + label_17: { + int _d4 = func_1176__h4(iL, memory, instance); + if (_d4 == 1) + break label_15; + if (_d4 == 2) + break label_13; + if (_d4 == 3) + break label_14; + if (_d4 == 4) + break label_16; + if (_d4 >= 10000) { + _hs[0] = (_d4 - 10000); + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_176 = new long[2]; + callArgs_176[1] = ((long) (iL[2] + 1520)); + callArgs_176[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_176); + long[] callArgs_177 = new long[1]; + callArgs_177[0] = ((long) 40); + long[] callResult_177 = instance.getMachine().call(1776, callArgs_177); + iL[0] = ((int) callResult_177[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (long) 5L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 49260); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 8; + break _hb; + } + } + int ciTableIdx_178 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_178 = instance.table(0).requiredRef(ciTableIdx_178); + com.dylibso.chicory.runtime.Instance ciRefInstance_178 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_178), instance); + if (!ciRefInstance_178.type(ciRefInstance_178.functionType(ciFuncId_178)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_178 = new long[1]; + callArgs_178[0] = ((long) iL[3]); + ciRefInstance_178.getMachine().call(ciFuncId_178, callArgs_178); + { + _hs[0] = 8; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + iL[4] = ((iL[2] + 1520) + 32); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + iL[6] = ((iL[2] + 1520) + 24); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + iL[7] = ((iL[2] + 1520) + 16); + memory.writeLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + iL[8] = ((iL[2] + 1520) + 8); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_179 = new long[2]; + callArgs_179[1] = ((long) (iL[2] + 1520)); + callArgs_179[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_179); + memory.writeI32((int) ((iL[2] + 688) + 16) < 0 ? ((iL[2] + 688) + 16) : ((iL[2] + 688) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 688) + 8) < 0 ? ((iL[2] + 688) + 8) : ((iL[2] + 688) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) ((iL[2] + 648) + 8) < 0 ? ((iL[2] + 648) + 8) : ((iL[2] + 648) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + memory.writeLong((int) ((iL[2] + 648) + 16) < 0 ? ((iL[2] + 648) + 16) : ((iL[2] + 648) + 16) + 0, (long) memory.readLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0)); + memory.writeLong((int) ((iL[2] + 648) + 24) < 0 ? ((iL[2] + 648) + 24) : ((iL[2] + 648) + 24) + 0, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + memory.writeI32((int) ((iL[2] + 648) + 32) < 0 ? ((iL[2] + 648) + 32) : ((iL[2] + 648) + 32) + 0, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 688, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 648, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520)); + long[] callArgs_180 = new long[4]; + callArgs_180[3] = ((long) iL[1]); + callArgs_180[2] = ((long) (iL[2] + 648)); + callArgs_180[1] = ((long) (iL[2] + 688)); + callArgs_180[0] = ((long) iL[0]); + long[] callResult_180 = instance.getMachine().call(1289, callArgs_180); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_180[0])) != 0) { + { + _hs[0] = 8; + break _hb; + } + } + { + _hs[0] = 1; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + iL[4] = ((iL[2] + 1520) + 32); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + iL[6] = ((iL[2] + 1520) + 24); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + iL[7] = ((iL[2] + 1520) + 16); + memory.writeLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + iL[8] = ((iL[2] + 1520) + 8); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_181 = new long[2]; + callArgs_181[1] = ((long) (iL[2] + 1520)); + callArgs_181[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_181); + memory.writeI32((int) ((iL[2] + 752) + 16) < 0 ? ((iL[2] + 752) + 16) : ((iL[2] + 752) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 752) + 8) < 0 ? ((iL[2] + 752) + 8) : ((iL[2] + 752) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) ((iL[2] + 712) + 8) < 0 ? ((iL[2] + 712) + 8) : ((iL[2] + 712) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + memory.writeLong((int) ((iL[2] + 712) + 16) < 0 ? ((iL[2] + 712) + 16) : ((iL[2] + 712) + 16) + 0, (long) memory.readLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0)); + memory.writeLong((int) ((iL[2] + 712) + 24) < 0 ? ((iL[2] + 712) + 24) : ((iL[2] + 712) + 24) + 0, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + memory.writeI32((int) ((iL[2] + 712) + 32) < 0 ? ((iL[2] + 712) + 32) : ((iL[2] + 712) + 32) + 0, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 752, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 712, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520)); + long[] callArgs_182 = new long[4]; + callArgs_182[3] = ((long) iL[1]); + callArgs_182[2] = ((long) (iL[2] + 712)); + callArgs_182[1] = ((long) (iL[2] + 752)); + callArgs_182[0] = ((long) iL[0]); + long[] callResult_182 = instance.getMachine().call(1290, callArgs_182); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_182[0])) != 0) { + { + _hs[0] = 8; + break _hb; + } + } + { + _hs[0] = 1; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + iL[4] = ((iL[2] + 1520) + 32); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + iL[6] = ((iL[2] + 1520) + 24); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + iL[7] = ((iL[2] + 1520) + 16); + memory.writeLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + iL[8] = ((iL[2] + 1520) + 8); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_183 = new long[2]; + callArgs_183[1] = ((long) (iL[2] + 1520)); + callArgs_183[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_183); + memory.writeI32((int) ((iL[2] + 816) + 16) < 0 ? ((iL[2] + 816) + 16) : ((iL[2] + 816) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 816) + 8) < 0 ? ((iL[2] + 816) + 8) : ((iL[2] + 816) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) ((iL[2] + 776) + 8) < 0 ? ((iL[2] + 776) + 8) : ((iL[2] + 776) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + memory.writeLong((int) ((iL[2] + 776) + 16) < 0 ? ((iL[2] + 776) + 16) : ((iL[2] + 776) + 16) + 0, (long) memory.readLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0)); + memory.writeLong((int) ((iL[2] + 776) + 24) < 0 ? ((iL[2] + 776) + 24) : ((iL[2] + 776) + 24) + 0, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + memory.writeI32((int) ((iL[2] + 776) + 32) < 0 ? ((iL[2] + 776) + 32) : ((iL[2] + 776) + 32) + 0, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 816, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 776, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520)); + long[] callArgs_184 = new long[4]; + callArgs_184[3] = ((long) iL[1]); + callArgs_184[2] = ((long) (iL[2] + 776)); + callArgs_184[1] = ((long) (iL[2] + 816)); + callArgs_184[0] = ((long) iL[0]); + long[] callResult_184 = instance.getMachine().call(1291, callArgs_184); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_184[0])) != 0) { + { + _hs[0] = 8; + break _hb; + } + } + { + _hs[0] = 1; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + iL[4] = ((iL[2] + 1520) + 32); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + iL[6] = ((iL[2] + 1520) + 24); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + iL[7] = ((iL[2] + 1520) + 16); + memory.writeLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + iL[8] = ((iL[2] + 1520) + 8); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_185 = new long[2]; + callArgs_185[1] = ((long) (iL[2] + 1520)); + callArgs_185[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_185); + memory.writeI32((int) ((iL[2] + 880) + 16) < 0 ? ((iL[2] + 880) + 16) : ((iL[2] + 880) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 880) + 8) < 0 ? ((iL[2] + 880) + 8) : ((iL[2] + 880) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) ((iL[2] + 840) + 8) < 0 ? ((iL[2] + 840) + 8) : ((iL[2] + 840) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + memory.writeLong((int) ((iL[2] + 840) + 16) < 0 ? ((iL[2] + 840) + 16) : ((iL[2] + 840) + 16) + 0, (long) memory.readLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0)); + memory.writeLong((int) ((iL[2] + 840) + 24) < 0 ? ((iL[2] + 840) + 24) : ((iL[2] + 840) + 24) + 0, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + memory.writeI32((int) ((iL[2] + 840) + 32) < 0 ? ((iL[2] + 840) + 32) : ((iL[2] + 840) + 32) + 0, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 880, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 840, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520)); + long[] callArgs_186 = new long[4]; + callArgs_186[3] = ((long) iL[1]); + callArgs_186[2] = ((long) (iL[2] + 840)); + callArgs_186[1] = ((long) (iL[2] + 880)); + callArgs_186[0] = ((long) iL[0]); + long[] callResult_186 = instance.getMachine().call(1292, callArgs_186); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_186[0])) != 0) { + { + _hs[0] = 8; + break _hb; + } + } + { + _hs[0] = 1; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1783__h1(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_66: { + label_67: { + label_68: { + iL[5] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657712); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_68; + } + iL[6] = 658136; + label_69: while (true) { + iL[8] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0); + iL[11] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ((iL[8] + iL[11]), iL[0]) != 0) { + break label_67; + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 8); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_69; + } + break label_66; + } + } + label_70: { + label_71: { + iL[6] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657704); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_71; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[6]) != 0) { + break label_70; + } + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657704, (int) iL[0]); + } + iL[6] = 0; + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658140, (int) iL[9]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658136, (int) iL[0]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657720, (int) -1); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657724, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 658160)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658148, (int) 0); + label_72: while (true) { + iL[5] = (iL[6] + 657736); + memory.writeI32((int) (iL[6] + 657748) < 0 ? (iL[6] + 657748) : (iL[6] + 657748) + 0, (int) iL[5]); + iL[8] = (iL[6] + 657728); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) iL[8]); + memory.writeI32((int) (iL[6] + 657740) < 0 ? (iL[6] + 657740) : (iL[6] + 657740) + 0, (int) iL[8]); + iL[8] = (iL[6] + 657744); + memory.writeI32((int) (iL[6] + 657756) < 0 ? (iL[6] + 657756) : (iL[6] + 657756) + 0, (int) iL[8]); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) iL[5]); + iL[5] = (iL[6] + 657752); + memory.writeI32((int) (iL[6] + 657764) < 0 ? (iL[6] + 657764) : (iL[6] + 657764) + 0, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) iL[8]); + memory.writeI32((int) (iL[6] + 657760) < 0 ? (iL[6] + 657760) : (iL[6] + 657760) + 0, (int) iL[5]); + iL[6] = (iL[6] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(256, iL[6]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_72; + } + break; + } + iL[6] = (((iL[0] + 8) & 15) != 0 ? ((-8 - iL[0]) & 15) : 0); + iL[5] = (iL[0] + iL[6]); + iL[8] = (iL[9] + -56); + iL[6] = (iL[8] - iL[6]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 4, (int) (iL[6] | 1)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657716, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 658176)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657700, (int) iL[6]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657712, (int) iL[5]); + memory.writeI32((int) (iL[0] + iL[8]) < 0 ? (iL[0] + iL[8]) : (iL[0] + iL[8]) + 4, (int) 56); + break _hb; + } + if ((((int) memory.read((int) iL[6] < 0 ? iL[6] : iL[6] + 12) & 0xFF) & 8) != 0) { + break label_66; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[5], iL[8]) != 0) { + break label_66; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[5], iL[0]) != 0) { + break label_66; + } + iL[8] = (((iL[5] + 8) & 15) != 0 ? ((-8 - iL[5]) & 15) : 0); + iL[0] = (iL[5] + iL[8]); + iL[4] = (memory.readInt((int) 0 < 0 ? 0 : 0 + 657700) + iL[9]); + iL[8] = (iL[4] - iL[8]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (int) (iL[8] | 1)); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 4, (int) (iL[11] + iL[9])); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657716, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 658176)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657700, (int) iL[8]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657712, (int) iL[0]); + memory.writeI32((int) (iL[5] + iL[4]) < 0 ? (iL[5] + iL[4]) : (iL[5] + iL[4]) + 4, (int) 56); + break _hb; + } + label_73: { + iL[11] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657704); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[11]) != 0) { + break label_73; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657704, (int) iL[0]); + iL[11] = iL[0]; + } + iL[8] = (iL[0] + iL[9]); + iL[6] = 658136; + label_74: { + label_75: { + label_76: { + label_77: { + label_78: { + label_79: { + label_80: { + label_81: while (true) { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[8], memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0)) != 0) { + break label_80; + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 8); + if (iL[6] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_81; + } + break label_79; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) iL[6] < 0 ? iL[6] : iL[6] + 12) & 0xFF) & 8)) != 0) { + break label_78; + } + } + iL[6] = 658136; + label_82: while (true) { + label_83: { + iL[8] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[8], iL[5]) != 0) { + break label_83; + } + iL[8] = (iL[8] + memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[8], iL[5]) != 0) { + break label_77; + } + } + iL[6] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 8); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_82; + } + } + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (int) iL[0]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 4, (int) (memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 4) + iL[9])); + iL[4] = (iL[0] + (((iL[0] + 8) & 15) != 0 ? ((-8 - iL[0]) & 15) : 0)); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 4, (int) (iL[7] | 3)); + iL[9] = (iL[8] + (((iL[8] + 8) & 15) != 0 ? ((-8 - iL[8]) & 15) : 0)); + iL[7] = (iL[4] + iL[7]); + iL[6] = (iL[9] - iL[7]); + label_84: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[5], iL[9]) != 0) { + break label_84; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657712, (int) iL[7]); + iL[6] = (memory.readInt((int) 0 < 0 ? 0 : 0 + 657700) + iL[6]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657700, (int) iL[6]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 4, (int) (iL[6] | 1)); + break label_75; + } + label_85: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) 0 < 0 ? 0 : 0 + 657708), iL[9]) != 0) { + break label_85; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657708, (int) iL[7]); + iL[6] = (memory.readInt((int) 0 < 0 ? 0 : 0 + 657696) + iL[6]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657696, (int) iL[6]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 4, (int) (iL[6] | 1)); + memory.writeI32((int) (iL[7] + iL[6]) < 0 ? (iL[7] + iL[6]) : (iL[7] + iL[6]) + 0, (int) iL[6]); + break label_75; + } + label_86: { + iL[5] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, (iL[5] & 3)) != 0) { + break label_86; + } + iL[10] = (iL[5] & -8); + label_87: { + label_88: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[5], 255) != 0) { + break label_88; + } + iL[8] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 8); + iL[11] = (iL[5] >>> 3); + iL[0] = ((iL[11] << 3) + 657728); + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[0], iL[8]); + label_89: { + iL[5] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[8], iL[5]) != 0) { + break label_89; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 657688) & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, iL[11]))); + break label_87; + } + com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[0], iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 8, (int) iL[8]); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 12, (int) iL[5]); + break label_87; + } + iL[12] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 24); + label_90: { + label_91: { + iL[0] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[9], iL[0]) != 0) { + break label_91; + } + iL[5] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 8); + com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[5], iL[11]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 8, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 12, (int) iL[0]); + break label_90; + } + label_92: { + iL[5] = (iL[9] + 20); + iL[8] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0); + if (iL[8] != 0) { + break label_92; + } + iL[5] = (iL[9] + 16); + iL[8] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0); + if (iL[8] != 0) { + break label_92; + } + iL[0] = 0; + break label_90; + } + label_93: while (true) { + iL[11] = iL[5]; + iL[0] = iL[8]; + iL[5] = (iL[0] + 20); + iL[8] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0); + if (iL[8] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_93; + } + iL[5] = (iL[0] + 16); + iL[8] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 16); + if (iL[8] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_93; + } + break; + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) 0); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[12]) != 0) { + break label_87; + } + label_94: { + label_95: { + iL[8] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 28); + iL[5] = ((iL[8] << 2) + 657992); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0), iL[9]) != 0) { + break label_95; + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) iL[0]); + if (iL[0] != 0) { + break label_94; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (memory.readInt((int) 0 < 0 ? 0 : 0 + 657692) & com.dylibso.chicory.runtime.OpcodeImpl.I32_ROTL(-2, iL[8]))); + break label_87; + } + memory.writeI32((int) (iL[12] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[9], memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 16)) != 0 ? 16 : 20)) < 0 ? (iL[12] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[9], memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 16)) != 0 ? 16 : 20)) : (iL[12] + (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[9], memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 16)) != 0 ? 16 : 20)) + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_87; + } + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 24, (int) iL[12]); + label_96: { + iL[5] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_96; + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 16, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 24, (int) iL[0]); + } + iL[5] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_87; + } + memory.writeI32((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 24, (int) iL[0]); + } + iL[6] = (iL[10] + iL[6]); + iL[9] = (iL[9] + iL[10]); + iL[5] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 4); + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 4, (int) (iL[5] & -2)); + memory.writeI32((int) (iL[7] + iL[6]) < 0 ? (iL[7] + iL[6]) : (iL[7] + iL[6]) + 0, (int) iL[6]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 4, (int) (iL[6] | 1)); + label_97: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[6], 255) != 0) { + break label_97; + } + iL[5] = ((iL[6] & -8) + 657728); + label_98: { + label_99: { + iL[8] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657688); + iL[6] = (1 << (iL[6] >>> 3)); + if ((iL[8] & iL[6]) != 0) { + break label_99; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (iL[8] | iL[6])); + iL[6] = iL[5]; + break label_98; + } + iL[6] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 8); + } + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 12, (int) iL[7]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 8, (int) iL[7]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 12, (int) iL[5]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 8, (int) iL[6]); + break label_75; + } + iL[5] = 31; + label_100: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[6], 16777215) != 0) { + break label_100; + } + iL[5] = com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ((iL[6] >>> 8)); + iL[5] = ((((iL[6] >>> (38 - iL[5])) & 1) - (iL[5] << 1)) + 62); + } + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 28, (int) iL[5]); + memory.writeLong((int) iL[7] < 0 ? iL[7] : iL[7] + 16, (long) 0L); + iL[8] = ((iL[5] << 2) + 657992); + label_101: { + iL[0] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657692); + iL[11] = (1 << iL[5]); + if ((iL[0] & iL[11]) != 0) { + break label_101; + } + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) iL[7]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (iL[0] | iL[11])); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 24, (int) iL[8]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 8, (int) iL[7]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 12, (int) iL[7]); + break label_75; + } + iL[5] = (iL[6] << (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(31, iL[5]) != 0 ? 0 : (25 - (iL[5] >>> 1)))); + iL[0] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + label_102: while (true) { + iL[8] = iL[0]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[6], (memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 4) & -8)) != 0) { + break label_76; + } + iL[0] = (iL[5] >>> 29); + iL[5] = (iL[5] << 1); + iL[11] = ((iL[8] + (iL[0] & 4)) + 16); + iL[0] = memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0); + if (iL[0] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_102; + } + break; + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) iL[7]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 24, (int) iL[8]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 12, (int) iL[7]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 8, (int) iL[7]); + break label_75; + } + iL[6] = (((iL[0] + 8) & 15) != 0 ? ((-8 - iL[0]) & 15) : 0); + iL[4] = (iL[0] + iL[6]); + iL[11] = (iL[9] + -56); + iL[6] = (iL[11] - iL[6]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 4, (int) (iL[6] | 1)); + memory.writeI32((int) (iL[0] + iL[11]) < 0 ? (iL[0] + iL[11]) : (iL[0] + iL[11]) + 4, (int) 56); + iL[11] = ((iL[8] + (((iL[8] + -55) & 15) != 0 ? ((55 - iL[8]) & 15) : 0)) + -63); + iL[11] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[11], (iL[5] + 16)) != 0 ? iL[5] : iL[11]); + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 4, (int) 35); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657716, (int) memory.readInt((int) 0 < 0 ? 0 : 0 + 658176)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657700, (int) iL[6]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657712, (int) iL[4]); + memory.writeLong((int) (iL[11] + 16) < 0 ? (iL[11] + 16) : (iL[11] + 16) + 0, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 658144)); + memory.writeLong((int) iL[11] < 0 ? iL[11] : iL[11] + 8, (long) memory.readLong((int) 0 < 0 ? 0 : 0 + 658136)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658144, (int) (iL[11] + 8)); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658140, (int) iL[9]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658136, (int) iL[0]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 658148, (int) 0); + iL[6] = (iL[11] + 36); + label_103: while (true) { + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (int) 7); + iL[6] = (iL[6] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[6], iL[8]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_103; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[5], iL[11]) != 0) { + break _hb; + } + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 4, (int) (memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 4) & -2)); + iL[0] = (iL[11] - iL[5]); + memory.writeI32((int) iL[11] < 0 ? iL[11] : iL[11] + 0, (int) iL[0]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 4, (int) (iL[0] | 1)); + label_104: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[0], 255) != 0) { + break label_104; + } + iL[6] = ((iL[0] & -8) + 657728); + label_105: { + label_106: { + iL[8] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657688); + iL[0] = (1 << (iL[0] >>> 3)); + if ((iL[8] & iL[0]) != 0) { + break label_106; + } + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657688, (int) (iL[8] | iL[0])); + iL[8] = iL[6]; + break label_105; + } + iL[8] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 8); + } + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 12, (int) iL[5]); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 8, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 12, (int) iL[6]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 8, (int) iL[8]); + break _hb; + } + iL[6] = 31; + label_107: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[0], 16777215) != 0) { + break label_107; + } + iL[6] = com.dylibso.chicory.runtime.OpcodeImpl.I32_CLZ((iL[0] >>> 8)); + iL[6] = ((((iL[0] >>> (38 - iL[6])) & 1) - (iL[6] << 1)) + 62); + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 28, (int) iL[6]); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 16, (long) 0L); + iL[8] = ((iL[6] << 2) + 657992); + label_108: { + iL[11] = memory.readInt((int) 0 < 0 ? 0 : 0 + 657692); + iL[9] = (1 << iL[6]); + if ((iL[11] & iL[9]) != 0) { + break label_108; + } + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) iL[5]); + memory.writeI32((int) 0 < 0 ? 0 : 0 + 657692, (int) (iL[11] | iL[9])); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 24, (int) iL[8]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 8, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 12, (int) iL[5]); + break _hb; + } + iL[6] = (iL[0] << (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(31, iL[6]) != 0 ? 0 : (25 - (iL[6] >>> 1)))); + iL[11] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + label_109: while (true) { + iL[8] = iL[11]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[0], (memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 4) & -8)) != 0) { + break label_74; + } + iL[11] = (iL[6] >>> 29); + iL[6] = (iL[6] << 1); + iL[9] = ((iL[8] + (iL[11] & 4)) + 16); + iL[11] = memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0); + if (iL[11] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_109; + } + break; + } + memory.writeI32((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 24, (int) iL[8]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 12, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 8, (int) iL[5]); + break _hb; + } + iL[6] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 8); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 12, (int) iL[7]); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 8, (int) iL[7]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 24, (int) 0); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 12, (int) iL[8]); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 8, (int) iL[6]); + } + iL[6] = (iL[4] + 8); + { + _hs[0] = 1; + break _hb; + } + } + iL[6] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 8); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 12, (int) iL[5]); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 8, (int) iL[5]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 24, (int) 0); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 12, (int) iL[8]); + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 8, (int) iL[6]); + } while (false); + return _hs[0]; + } + + private static int func_1871__h1(int[] iL, long[] lL, double[] dL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_7: { + label_8: { + label_9: { + label_10: { + int _d0 = func_1871__h0(iL, lL, dL, memory, instance); + if (_d0 == 1) { + _hs[0] = 1; + break _hb; + } + if (_d0 == 2) { + _hs[0] = 2; + break _hb; + } + if (_d0 == 3) { + _hs[0] = 3; + break _hb; + } + if (_d0 == 4) + break label_9; + if (_d0 == 5) { + _hs[0] = 4; + break _hb; + } + if (_d0 == 6) + break _hb; + if (_d0 == 7) + break label_8; + if (_d0 == 8) + break label_7; + } + iL[29] = 0; + iL[24] = 2575; + iL[20] = iL[17]; + iL[30] = iL[31]; + iL[26] = iL[25]; + } + iL[25] = (iL[20] - iL[21]); + iL[28] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[26], iL[25]) != 0 ? iL[26] : iL[25]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[28], (iL[29] ^ 2147483647)) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[23] = (iL[29] + iL[28]); + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[27], iL[23]) != 0 ? iL[27] : iL[23]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[20], iL[22]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + label_197: { + iL[30] = (iL[30] & 73728); + if (iL[30] != 0) { + break label_197; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[23], iL[27]) != 0) { + break label_197; + } + iL[22] = (iL[20] - iL[23]); + iL[31] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[22], 256); + long[] callArgs_45 = new long[3]; + callArgs_45[2] = ((long) (iL[31] != 0 ? iL[22] : 256)); + callArgs_45[1] = ((long) 32); + callArgs_45[0] = ((long) (iL[6] + 112)); + long[] callResult_45 = instance.getMachine().call(1892, callArgs_45); + label_198: { + if (iL[31] != 0) { + break label_198; + } + label_199: while (true) { + label_200: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_200; + } + long[] callArgs_46 = new long[3]; + callArgs_46[2] = ((long) iL[0]); + callArgs_46[1] = ((long) 256); + callArgs_46[0] = ((long) (iL[6] + 112)); + long[] callResult_46 = instance.getMachine().call(1855, callArgs_46); + } + iL[22] = (iL[22] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[22], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_199; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_197; + } + long[] callArgs_47 = new long[3]; + callArgs_47[2] = ((long) iL[0]); + callArgs_47[1] = ((long) iL[22]); + callArgs_47[0] = ((long) (iL[6] + 112)); + long[] callResult_47 = instance.getMachine().call(1855, callArgs_47); + } + label_201: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_201; + } + long[] callArgs_48 = new long[3]; + callArgs_48[2] = ((long) iL[0]); + callArgs_48[1] = ((long) iL[29]); + callArgs_48[0] = ((long) iL[24]); + long[] callResult_48 = instance.getMachine().call(1855, callArgs_48); + } + label_202: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(65536, iL[30]) != 0) { + break label_202; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[23], iL[27]) != 0) { + break label_202; + } + iL[22] = (iL[20] - iL[23]); + iL[29] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[22], 256); + long[] callArgs_49 = new long[3]; + callArgs_49[2] = ((long) (iL[29] != 0 ? iL[22] : 256)); + callArgs_49[1] = ((long) 48); + callArgs_49[0] = ((long) (iL[6] + 112)); + long[] callResult_49 = instance.getMachine().call(1892, callArgs_49); + label_203: { + if (iL[29] != 0) { + break label_203; + } + label_204: while (true) { + label_205: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_205; + } + long[] callArgs_50 = new long[3]; + callArgs_50[2] = ((long) iL[0]); + callArgs_50[1] = ((long) 256); + callArgs_50[0] = ((long) (iL[6] + 112)); + long[] callResult_50 = instance.getMachine().call(1855, callArgs_50); + } + iL[22] = (iL[22] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[22], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_204; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_202; + } + long[] callArgs_51 = new long[3]; + callArgs_51[2] = ((long) iL[0]); + callArgs_51[1] = ((long) iL[22]); + callArgs_51[0] = ((long) (iL[6] + 112)); + long[] callResult_51 = instance.getMachine().call(1855, callArgs_51); + } + label_206: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[25], iL[26]) != 0) { + break label_206; + } + iL[22] = (iL[28] - iL[25]); + iL[26] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[22], 256); + long[] callArgs_52 = new long[3]; + callArgs_52[2] = ((long) (iL[26] != 0 ? iL[22] : 256)); + callArgs_52[1] = ((long) 48); + callArgs_52[0] = ((long) (iL[6] + 112)); + long[] callResult_52 = instance.getMachine().call(1892, callArgs_52); + label_207: { + if (iL[26] != 0) { + break label_207; + } + label_208: while (true) { + label_209: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_209; + } + long[] callArgs_53 = new long[3]; + callArgs_53[2] = ((long) iL[0]); + callArgs_53[1] = ((long) 256); + callArgs_53[0] = ((long) (iL[6] + 112)); + long[] callResult_53 = instance.getMachine().call(1855, callArgs_53); + } + iL[22] = (iL[22] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[22], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_208; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_206; + } + long[] callArgs_54 = new long[3]; + callArgs_54[2] = ((long) iL[0]); + callArgs_54[1] = ((long) iL[22]); + callArgs_54[0] = ((long) (iL[6] + 112)); + long[] callResult_54 = instance.getMachine().call(1855, callArgs_54); + } + label_210: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_210; + } + long[] callArgs_55 = new long[3]; + callArgs_55[2] = ((long) iL[0]); + callArgs_55[1] = ((long) iL[25]); + callArgs_55[0] = ((long) iL[21]); + long[] callResult_55 = instance.getMachine().call(1855, callArgs_55); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8192, iL[30]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 2; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[23], iL[27]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 2; + break _hb; + } + } + iL[22] = (iL[20] - iL[23]); + iL[23] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[22], 256); + long[] callArgs_56 = new long[3]; + callArgs_56[2] = ((long) (iL[23] != 0 ? iL[22] : 256)); + callArgs_56[1] = ((long) 32); + callArgs_56[0] = ((long) (iL[6] + 112)); + long[] callResult_56 = instance.getMachine().call(1892, callArgs_56); + label_211: { + if (iL[23] != 0) { + break label_211; + } + label_212: while (true) { + label_213: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_213; + } + long[] callArgs_57 = new long[3]; + callArgs_57[2] = ((long) iL[0]); + callArgs_57[1] = ((long) 256); + callArgs_57[0] = ((long) (iL[6] + 112)); + long[] callResult_57 = instance.getMachine().call(1855, callArgs_57); + } + iL[22] = (iL[22] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[22], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_212; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 2; + break _hb; + } + } + long[] callArgs_58 = new long[3]; + callArgs_58[2] = ((long) iL[0]); + callArgs_58[1] = ((long) iL[22]); + callArgs_58[0] = ((long) (iL[6] + 112)); + long[] callResult_58 = instance.getMachine().call(1855, callArgs_58); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 2; + break _hb; + } + } + label_214: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[28], 0) != 0) { + break label_214; + } + iL[30] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[30], iL[23]) != 0 ? iL[30] : (iL[23] + 4)); + iL[25] = iL[23]; + label_215: while (true) { + label_216: { + label_217: { + iL[20] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[20]) != 0) { + break label_217; + } + iL[22] = 0; + label_218: while (true) { + iL[21] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[20], 10); + memory.writeByte((int) (((iL[6] + 80) + iL[22]) + 8) < 0 ? (((iL[6] + 80) + iL[22]) + 8) : (((iL[6] + 80) + iL[22]) + 8) + 0, (byte) (((iL[20] - (iL[21] * 10)) | 48))); + iL[22] = (iL[22] + -1); + iL[26] = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 9); + iL[20] = iL[21]; + if (iL[26] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_218; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[22]) != 0) { + break label_217; + } + iL[20] = (((iL[6] + 80) + iL[22]) + 9); + break label_216; + } + memory.writeByte((int) iL[6] < 0 ? iL[6] : iL[6] + 88, (byte) (48)); + iL[20] = iL[13]; + } + label_219: { + label_220: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[23], iL[25]) != 0) { + break label_220; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[20], (iL[6] + 80)) != 0) { + break label_219; + } + long[] callArgs_59 = new long[3]; + callArgs_59[2] = ((long) (iL[20] - (iL[6] + 80))); + callArgs_59[1] = ((long) 48); + callArgs_59[0] = ((long) (iL[6] + 80)); + long[] callResult_59 = instance.getMachine().call(1892, callArgs_59); + iL[20] = (iL[6] + 80); + break label_219; + } + label_221: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_221; + } + long[] callArgs_60 = new long[3]; + callArgs_60[2] = ((long) iL[0]); + callArgs_60[1] = ((long) 1); + callArgs_60[0] = ((long) iL[20]); + long[] callResult_60 = instance.getMachine().call(1855, callArgs_60); + } + iL[20] = (iL[20] + 1); + label_222: { + if (iL[39] != 0) { + break label_222; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[28], 1) != 0) { + break label_219; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_219; + } + long[] callArgs_61 = new long[3]; + callArgs_61[2] = ((long) iL[0]); + callArgs_61[1] = ((long) 1); + callArgs_61[0] = ((long) 29323); + long[] callResult_61 = instance.getMachine().call(1855, callArgs_61); + } + iL[22] = (iL[14] - iL[20]); + label_223: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_223; + } + long[] callArgs_62 = new long[3]; + callArgs_62[2] = ((long) iL[0]); + callArgs_62[1] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[28], iL[22]) != 0 ? iL[28] : iL[22])); + callArgs_62[0] = ((long) iL[20]); + long[] callResult_62 = instance.getMachine().call(1855, callArgs_62); + } + iL[28] = (iL[28] - iL[22]); + iL[25] = (iL[25] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[25], iL[30]) != 0) { + break label_214; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[28], -1) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_215; + } + break; + } + } + long[] callArgs_63 = new long[5]; + callArgs_63[4] = ((long) 0); + callArgs_63[3] = ((long) 18); + callArgs_63[2] = ((long) (iL[28] + 18)); + callArgs_63[1] = ((long) 48); + callArgs_63[0] = ((long) iL[0]); + instance.getMachine().call(1873, callArgs_63); + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_7; + } + long[] callArgs_64 = new long[3]; + callArgs_64[2] = ((long) iL[0]); + callArgs_64[1] = ((long) (iL[7] - iL[38])); + callArgs_64[0] = ((long) iL[38]); + long[] callResult_64 = instance.getMachine().call(1855, callArgs_64); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8192, iL[31]) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[27], iL[29]) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + iL[20] = (iL[27] - iL[29]); + iL[22] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[20], 256); + long[] callArgs_65 = new long[3]; + callArgs_65[2] = ((long) (iL[22] != 0 ? iL[20] : 256)); + callArgs_65[1] = ((long) 32); + callArgs_65[0] = ((long) (iL[6] + 624)); + long[] callResult_65 = instance.getMachine().call(1892, callArgs_65); + label_224: { + if (iL[22] != 0) { + break label_224; + } + label_225: while (true) { + label_226: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_226; + } + long[] callArgs_66 = new long[3]; + callArgs_66[2] = ((long) iL[0]); + callArgs_66[1] = ((long) 256); + callArgs_66[0] = ((long) (iL[6] + 624)); + long[] callResult_66 = instance.getMachine().call(1855, callArgs_66); + } + iL[20] = (iL[20] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_225; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + long[] callArgs_67 = new long[3]; + callArgs_67[2] = ((long) iL[0]); + callArgs_67[1] = ((long) iL[20]); + callArgs_67[0] = ((long) (iL[6] + 624)); + long[] callResult_67 = instance.getMachine().call(1855, callArgs_67); + { + _hs[0] = 5; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1883_helper1(int _sel, int[] iL, long[] lL, double[] dL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + switch(_sel) { + case 0: + { + { + _hs[0] = 1; + break _hb; + } + } + case 1: + { + { + _hs[0] = 2; + break _hb; + } + } + } + } while (false); + return _hs[0]; + } + + private static int func_1883_helper2(int _sel, int[] iL, long[] lL, double[] dL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + switch(_sel) { + case 2: + { + { + _hs[0] = 2; + break _hb; + } + } + default: + { + { + _hs[0] = 3; + break _hb; + } + } + } + } while (false); + return _hs[0]; + } + + private static int func_51__h2(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_40: { + label_41: { + label_42: { + label_43: { + label_44: { + label_45: { + label_46: { + label_47: { + label_48: { + label_49: { + int _d3 = func_51__h3(iL, lL, memory, instance); + if (_d3 == 1) + break label_48; + if (_d3 == 2) + break label_47; + if (_d3 == 3) + break label_46; + if (_d3 == 4) + break label_45; + if (_d3 == 5) + break label_44; + if (_d3 == 6) + break label_43; + if (_d3 == 7) + break label_42; + if (_d3 == 8) + break label_41; + if (_d3 == 9) + break label_40; + if (_d3 >= 10000) { + _hs[0] = (_d3 - 10000); + break _hb; + } + } + long[] callArgs_38 = new long[2]; + callArgs_38[1] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)); + callArgs_38[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_38); + { + _hs[0] = 10023; + break _hb; + } + } + label_69: { + label_70: { + label_71: { + label_72: { + label_73: { + switch((memory.readInt((int) (iL[2] + 56) < 0 ? (iL[2] + 56) : (iL[2] + 56) + 0) + 5)) { + case 0: + { + break label_69; + } + case 1: + { + break label_70; + } + case 2: + { + break label_71; + } + case 3: + { + break label_72; + } + case 4: + { + break label_73; + } + default: + { + { + _hs[0] = 10023; + break _hb; + } + } + } + } + long[] callArgs_39 = new long[2]; + callArgs_39[1] = ((long) 57); + callArgs_39[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_39); + long[] callArgs_40 = new long[3]; + callArgs_40[2] = ((long) 13590); + callArgs_40[1] = ((long) memory.readInt((int) (iL[2] + 72) < 0 ? (iL[2] + 72) : (iL[2] + 72) + 0)); + callArgs_40[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(173, callArgs_40); + { + _hs[0] = 10023; + break _hb; + } + } + long[] callArgs_41 = new long[2]; + callArgs_41[1] = ((long) 58); + callArgs_41[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_41); + long[] callArgs_42 = new long[3]; + callArgs_42[2] = ((long) 13566); + callArgs_42[1] = memory.readLong((int) (iL[2] + 72) < 0 ? (iL[2] + 72) : (iL[2] + 72) + 0); + callArgs_42[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(175, callArgs_42); + { + _hs[0] = 10023; + break _hb; + } + } + long[] callArgs_43 = new long[2]; + callArgs_43[1] = ((long) 59); + callArgs_43[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_43); + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) memory.readInt((int) (iL[2] + 72) < 0 ? (iL[2] + 72) : (iL[2] + 72) + 0)); + long[] callArgs_44 = new long[5]; + callArgs_44[4] = ((long) 0); + callArgs_44[3] = ((long) 13602); + callArgs_44[2] = ((long) 4); + callArgs_44[1] = ((long) (iL[3] + 16)); + callArgs_44[0] = ((long) iL[0]); + instance.getMachine().call(224, callArgs_44); + { + _hs[0] = 10023; + break _hb; + } + } + long[] callArgs_45 = new long[2]; + callArgs_45[1] = ((long) 60); + callArgs_45[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_45); + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (long) memory.readLong((int) (iL[2] + 72) < 0 ? (iL[2] + 72) : (iL[2] + 72) + 0)); + long[] callArgs_46 = new long[5]; + callArgs_46[4] = ((long) 0); + callArgs_46[3] = ((long) 13578); + callArgs_46[2] = ((long) 8); + callArgs_46[1] = ((long) (iL[3] + 16)); + callArgs_46[0] = ((long) iL[0]); + instance.getMachine().call(224, callArgs_46); + { + _hs[0] = 10023; + break _hb; + } + } + long[] callArgs_47 = new long[2]; + callArgs_47[1] = ((long) 231); + callArgs_47[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_47); + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0, (long) memory.readLong((int) (iL[2] + 80) < 0 ? (iL[2] + 80) : (iL[2] + 80) + 0)); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (long) memory.readLong((int) (iL[2] + 72) < 0 ? (iL[2] + 72) : (iL[2] + 72) + 0)); + long[] callArgs_48 = new long[5]; + callArgs_48[4] = ((long) 0); + callArgs_48[3] = ((long) 13553); + callArgs_48[2] = ((long) 16); + callArgs_48[1] = ((long) (iL[3] + 16)); + callArgs_48[0] = ((long) iL[0]); + instance.getMachine().call(224, callArgs_48); + { + _hs[0] = 10023; + break _hb; + } + } + long[] callArgs_49 = new long[2]; + callArgs_49[1] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)); + callArgs_49[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_49); + { + _hs[0] = 10023; + break _hb; + } + } + long[] callArgs_50 = new long[2]; + callArgs_50[1] = ((long) 23); + callArgs_50[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_50); + { + _hs[0] = 10023; + break _hb; + } + } + long[] callArgs_51 = new long[2]; + callArgs_51[1] = ((long) (iL[2] + 36)); + callArgs_51[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_51 = instance.getMachine().call(122, callArgs_51); + iL[2] = ((int) callResult_51[0]); + long[] callArgs_52 = new long[2]; + callArgs_52[1] = ((long) 30); + callArgs_52[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_52); + long[] callArgs_53 = new long[4]; + callArgs_53[3] = ((long) 7); + callArgs_53[2] = ((long) 1762); + callArgs_53[1] = ((long) iL[2]); + callArgs_53[0] = ((long) iL[0]); + instance.getMachine().call(63, callArgs_53); + { + _hs[0] = 10023; + break _hb; + } + } + long[] callArgs_54 = new long[2]; + callArgs_54[1] = ((long) (iL[2] + 36)); + callArgs_54[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_54 = instance.getMachine().call(122, callArgs_54); + iL[2] = ((int) callResult_54[0]); + long[] callArgs_55 = new long[2]; + callArgs_55[1] = ((long) 31); + callArgs_55[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_55); + long[] callArgs_56 = new long[4]; + callArgs_56[3] = ((long) 7); + callArgs_56[2] = ((long) 1762); + callArgs_56[1] = ((long) iL[2]); + callArgs_56[0] = ((long) iL[0]); + instance.getMachine().call(63, callArgs_56); + { + _hs[0] = 10023; + break _hb; + } + } + long[] callArgs_57 = new long[2]; + callArgs_57[1] = ((long) 4); + callArgs_57[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_57); + long[] callArgs_58 = new long[2]; + callArgs_58[1] = ((long) (iL[2] + 48)); + callArgs_58[0] = ((long) iL[0]); + instance.getMachine().call(62, callArgs_58); + long[] callArgs_59 = new long[3]; + callArgs_59[2] = ((long) (iL[2] + 152)); + callArgs_59[1] = ((long) iL[1]); + callArgs_59[0] = ((long) iL[0]); + instance.getMachine().call(55, callArgs_59); + label_74: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) (iL[2] + 192) < 0 ? (iL[2] + 192) : (iL[2] + 192) + 0)) != 0) { + break label_74; + } + long[] callArgs_60 = new long[2]; + callArgs_60[1] = ((long) 5); + callArgs_60[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_60); + long[] callArgs_61 = new long[3]; + callArgs_61[2] = ((long) (iL[2] + 184)); + callArgs_61[1] = ((long) iL[1]); + callArgs_61[0] = ((long) iL[0]); + instance.getMachine().call(55, callArgs_61); + } + long[] callArgs_62 = new long[2]; + callArgs_62[1] = ((long) 11); + callArgs_62[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_62); + { + _hs[0] = 10023; + break _hb; + } + } + long[] callArgs_63 = new long[2]; + callArgs_63[1] = ((long) iL[2]); + callArgs_63[0] = ((long) iL[0]); + instance.getMachine().call(65, callArgs_63); + { + _hs[0] = 10023; + break _hb; + } + } + label_75: { + label_76: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1]) != 0) { + break label_76; + } + long[] callArgs_64 = new long[2]; + callArgs_64[1] = ((long) (iL[2] + 36)); + callArgs_64[0] = ((long) iL[1]); + long[] callResult_64 = instance.getMachine().call(131, callArgs_64); + iL[1] = ((int) callResult_64[0]); + break label_75; + } + iL[1] = -1; + if (memory.readInt((int) (iL[2] + 56) < 0 ? (iL[2] + 56) : (iL[2] + 56) + 0) != 0) { + break label_75; + } + iL[1] = memory.readInt((int) (iL[2] + 60) < 0 ? (iL[2] + 60) : (iL[2] + 60) + 0); + } + long[] callArgs_65 = new long[2]; + callArgs_65[1] = ((long) 27); + callArgs_65[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_65); + long[] callArgs_66 = new long[3]; + callArgs_66[2] = ((long) 1695); + callArgs_66[1] = ((long) iL[1]); + callArgs_66[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_66); + { + _hs[0] = 10023; + break _hb; + } + } + label_77: { + label_78: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[1]) != 0) { + break label_78; + } + long[] callArgs_67 = new long[2]; + callArgs_67[1] = ((long) (iL[2] + 36)); + callArgs_67[0] = ((long) iL[1]); + long[] callResult_67 = instance.getMachine().call(131, callArgs_67); + iL[1] = ((int) callResult_67[0]); + break label_77; + } + iL[1] = -1; + if (memory.readInt((int) (iL[2] + 56) < 0 ? (iL[2] + 56) : (iL[2] + 56) + 0) != 0) { + break label_77; + } + iL[1] = memory.readInt((int) (iL[2] + 60) < 0 ? (iL[2] + 60) : (iL[2] + 60) + 0); + } + long[] callArgs_68 = new long[2]; + callArgs_68[1] = ((long) 28); + callArgs_68[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_68); + long[] callArgs_69 = new long[3]; + callArgs_69[2] = ((long) 1695); + callArgs_69[1] = ((long) iL[1]); + callArgs_69[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_69); + { + _hs[0] = 10023; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_194__h1(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + { + int _sel = (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + -6); + int _sw; + if (_sel < 268) { + _sw = func_194__h1_helper0(_sel, iL, memory, instance); + } else { + _sw = func_194__h1_helper1(_sel, iL, memory, instance); + } + if (_sw != 0) { + _hs[0] = _sw; + break _hb; + } + } + } while (false); + return _hs[0]; + } + + private static int func_450__h2(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_43: { + label_44: { + label_45: { + label_46: { + label_47: { + label_48: { + label_49: { + label_50: { + label_51: { + label_52: { + label_53: { + int _d3 = func_450__h3(iL, memory, instance); + if (_d3 == 1) + break label_52; + if (_d3 == 2) + break label_51; + if (_d3 == 3) + break label_50; + if (_d3 == 4) + break label_49; + if (_d3 == 5) + break label_48; + if (_d3 == 6) + break label_47; + if (_d3 == 7) + break label_46; + if (_d3 == 8) + break label_45; + if (_d3 == 9) + break label_44; + if (_d3 == 10) + break label_43; + if (_d3 >= 10000) { + _hs[0] = (_d3 - 10000); + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_15 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 48)); + int ciFuncId_15 = instance.table(0).requiredRef(ciTableIdx_15); + com.dylibso.chicory.runtime.Instance ciRefInstance_15 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_15), instance); + if (!ciRefInstance_15.type(ciRefInstance_15.functionType(ciFuncId_15)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) iL[1]); + callArgs_15[0] = ((long) iL[0]); + long[] callResult_15 = ciRefInstance_15.getMachine().call(ciFuncId_15, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_15[0])) != 0) { + { + _hs[0] = 10024; + break _hb; + } + } + { + _hs[0] = 10025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_16 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 52)); + int ciFuncId_16 = instance.table(0).requiredRef(ciTableIdx_16); + com.dylibso.chicory.runtime.Instance ciRefInstance_16 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_16), instance); + if (!ciRefInstance_16.type(ciRefInstance_16.functionType(ciFuncId_16)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) iL[1]); + callArgs_16[0] = ((long) iL[0]); + long[] callResult_16 = ciRefInstance_16.getMachine().call(ciFuncId_16, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_16[0])) != 0) { + { + _hs[0] = 10024; + break _hb; + } + } + { + _hs[0] = 10025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_17 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 56)); + int ciFuncId_17 = instance.table(0).requiredRef(ciTableIdx_17); + com.dylibso.chicory.runtime.Instance ciRefInstance_17 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_17), instance); + if (!ciRefInstance_17.type(ciRefInstance_17.functionType(ciFuncId_17)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) iL[1]); + callArgs_17[0] = ((long) iL[0]); + long[] callResult_17 = ciRefInstance_17.getMachine().call(ciFuncId_17, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_17[0])) != 0) { + { + _hs[0] = 10024; + break _hb; + } + } + { + _hs[0] = 10025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_18 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 60)); + int ciFuncId_18 = instance.table(0).requiredRef(ciTableIdx_18); + com.dylibso.chicory.runtime.Instance ciRefInstance_18 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_18), instance); + if (!ciRefInstance_18.type(ciRefInstance_18.functionType(ciFuncId_18)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) iL[1]); + callArgs_18[0] = ((long) iL[0]); + long[] callResult_18 = ciRefInstance_18.getMachine().call(ciFuncId_18, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_18[0])) != 0) { + { + _hs[0] = 10024; + break _hb; + } + } + { + _hs[0] = 10025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_19 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 64)); + int ciFuncId_19 = instance.table(0).requiredRef(ciTableIdx_19); + com.dylibso.chicory.runtime.Instance ciRefInstance_19 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_19), instance); + if (!ciRefInstance_19.type(ciRefInstance_19.functionType(ciFuncId_19)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) iL[1]); + callArgs_19[0] = ((long) iL[0]); + long[] callResult_19 = ciRefInstance_19.getMachine().call(ciFuncId_19, callArgs_19); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_19[0])) != 0) { + { + _hs[0] = 10024; + break _hb; + } + } + { + _hs[0] = 10025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_20 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 68)); + int ciFuncId_20 = instance.table(0).requiredRef(ciTableIdx_20); + com.dylibso.chicory.runtime.Instance ciRefInstance_20 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_20), instance); + if (!ciRefInstance_20.type(ciRefInstance_20.functionType(ciFuncId_20)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) iL[1]); + callArgs_20[0] = ((long) iL[0]); + long[] callResult_20 = ciRefInstance_20.getMachine().call(ciFuncId_20, callArgs_20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_20[0])) != 0) { + { + _hs[0] = 10024; + break _hb; + } + } + { + _hs[0] = 10025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_21 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 72)); + int ciFuncId_21 = instance.table(0).requiredRef(ciTableIdx_21); + com.dylibso.chicory.runtime.Instance ciRefInstance_21 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_21), instance); + if (!ciRefInstance_21.type(ciRefInstance_21.functionType(ciFuncId_21)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) iL[1]); + callArgs_21[0] = ((long) iL[0]); + long[] callResult_21 = ciRefInstance_21.getMachine().call(ciFuncId_21, callArgs_21); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_21[0])) != 0) { + { + _hs[0] = 10024; + break _hb; + } + } + { + _hs[0] = 10025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_22 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 76)); + int ciFuncId_22 = instance.table(0).requiredRef(ciTableIdx_22); + com.dylibso.chicory.runtime.Instance ciRefInstance_22 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_22), instance); + if (!ciRefInstance_22.type(ciRefInstance_22.functionType(ciFuncId_22)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) iL[1]); + callArgs_22[0] = ((long) iL[0]); + long[] callResult_22 = ciRefInstance_22.getMachine().call(ciFuncId_22, callArgs_22); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_22[0])) != 0) { + { + _hs[0] = 10024; + break _hb; + } + } + { + _hs[0] = 10025; + break _hb; + } + } + iL[2] = 1; + iL[3] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_23 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 80)); + int ciFuncId_23 = instance.table(0).requiredRef(ciTableIdx_23); + com.dylibso.chicory.runtime.Instance ciRefInstance_23 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_23), instance); + if (!ciRefInstance_23.type(ciRefInstance_23.functionType(ciFuncId_23)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) iL[1]); + callArgs_23[0] = ((long) iL[3]); + long[] callResult_23 = ciRefInstance_23.getMachine().call(ciFuncId_23, callArgs_23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_23[0])) != 0) { + { + _hs[0] = 10025; + break _hb; + } + } + long[] callArgs_24 = new long[4]; + callArgs_24[3] = ((long) (iL[1] + 152)); + callArgs_24[2] = ((long) iL[1]); + callArgs_24[1] = ((long) 2); + callArgs_24[0] = ((long) iL[0]); + instance.getMachine().call(451, callArgs_24); + { + _hs[0] = 10024; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_25 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 92)); + int ciFuncId_25 = instance.table(0).requiredRef(ciTableIdx_25); + com.dylibso.chicory.runtime.Instance ciRefInstance_25 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_25), instance); + if (!ciRefInstance_25.type(ciRefInstance_25.functionType(ciFuncId_25)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) iL[1]); + callArgs_25[0] = ((long) iL[0]); + long[] callResult_25 = ciRefInstance_25.getMachine().call(ciFuncId_25, callArgs_25); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_25[0])) != 0) { + { + _hs[0] = 10024; + break _hb; + } + } + { + _hs[0] = 10025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_26 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 292)); + int ciFuncId_26 = instance.table(0).requiredRef(ciTableIdx_26); + com.dylibso.chicory.runtime.Instance ciRefInstance_26 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_26), instance); + if (!ciRefInstance_26.type(ciRefInstance_26.functionType(ciFuncId_26)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) iL[1]); + callArgs_26[0] = ((long) iL[0]); + long[] callResult_26 = ciRefInstance_26.getMachine().call(ciFuncId_26, callArgs_26); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_26[0])) != 0) { + { + _hs[0] = 10024; + break _hb; + } + } + { + _hs[0] = 10025; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_557__h1(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_19: { + label_20: { + label_21: { + label_22: { + int _d2 = func_557__h2(iL, memory, instance); + if (_d2 == 1) + break label_21; + if (_d2 == 2) + break label_20; + if (_d2 == 3) + break label_19; + if (_d2 >= 10000) { + _hs[0] = (_d2 - 10000); + break _hb; + } + } + iL[8] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16); + label_26: while (true) { + label_27: { + label_28: { + label_29: { + switch((((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF) + -9)) { + case 0: + { + break label_29; + } + case 1: + { + break label_28; + } + case 2: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 3: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 4: + { + break label_29; + } + case 5: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 6: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 7: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 8: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 9: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 10: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 11: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 12: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 13: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 14: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 15: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 16: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 17: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 18: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 19: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 20: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 21: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 22: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 23: + { + break label_29; + } + default: + { + { + _hs[0] = 10006; + break _hb; + } + } + } + } + iL[4] = (iL[4] + 1); + break label_27; + } + iL[4] = (iL[4] + 1); + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) iL[4]); + iL[8] = (iL[8] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 16, (int) iL[8]); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[4], iL[5]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_26; + } + { + _hs[0] = 10006; + break _hb; + } + } + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) iL[1]); + callArgs_1[0] = ((long) iL[0]); + instance.getMachine().call(558, callArgs_1); + { + _hs[0] = 10003; + break _hb; + } + } + iL[8] = (iL[4] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[8]); + label_30: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[8], iL[5]) != 0) { + break label_30; + } + label_31: { + label_32: { + iL[7] = ((int) memory.read((int) iL[8] < 0 ? iL[8] : iL[8] + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U((iL[7] + -49), 9) != 0) { + break label_32; + } + label_33: { + label_34: { + switch((iL[7] + -105)) { + case 0: + { + break label_34; + } + case 1: + { + break label_30; + } + case 2: + { + break label_30; + } + case 3: + { + break label_30; + } + case 4: + { + break label_30; + } + case 5: + { + break label_33; + } + default: + { + break label_31; + } + } + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) iL[1]); + callArgs_2[0] = ((long) iL[0]); + instance.getMachine().call(559, callArgs_2); + { + _hs[0] = 10003; + break _hb; + } + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) iL[1]); + callArgs_3[0] = ((long) iL[0]); + instance.getMachine().call(560, callArgs_3); + { + _hs[0] = 10003; + break _hb; + } + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 58); + callArgs_4[1] = ((long) iL[1]); + callArgs_4[0] = ((long) iL[0]); + instance.getMachine().call(561, callArgs_4); + { + _hs[0] = 10003; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(48, iL[7]) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) iL[1]); + callArgs_5[0] = ((long) iL[0]); + instance.getMachine().call(562, callArgs_5); + { + _hs[0] = 10003; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[4], iL[5]) != 0) { + { + _hs[0] = 10000; + break _hb; + } + } + iL[8] = (iL[4] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[8]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(48, ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF)) != 0) { + { + _hs[0] = 10000; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[8], iL[5]) != 0) { + { + _hs[0] = 7; + break _hb; + } + } + { + _hs[0] = 10000; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h2(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_48: { + label_49: { + int _d11 = func_801__h11(iL, lL, memory, instance); + if (_d11 == 1) + break label_48; + if (_d11 >= 10000) { + _hs[0] = (_d11 - 10000); + break _hb; + } + } + label_281: { + label_282: { + label_283: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_308 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 144)); + int ciFuncId_308 = instance.table(0).requiredRef(ciTableIdx_308); + com.dylibso.chicory.runtime.Instance ciRefInstance_308 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_308), instance); + if (!ciRefInstance_308.type(ciRefInstance_308.functionType(ciFuncId_308)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_308 = new long[2]; + callArgs_308[1] = ((long) iL[0]); + callArgs_308[0] = ((long) iL[3]); + long[] callResult_308 = ciRefInstance_308.getMachine().call(ciFuncId_308, callArgs_308); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_308[0])) != 0) { + break label_283; + } + long[] callArgs_309 = new long[3]; + callArgs_309[2] = ((long) 0); + callArgs_309[1] = ((long) 24043); + callArgs_309[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_309); + break label_282; + } + label_284: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_310 = new long[3]; + callArgs_310[2] = ((long) (iL[4] + 3168)); + callArgs_310[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_310[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_310 = instance.getMachine().call(177, callArgs_310); + iL[3] = ((int) callResult_310[0]); + if (iL[3] != 0) { + break label_284; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2192, (int) 6518); + long[] callArgs_311 = new long[3]; + callArgs_311[2] = ((long) (iL[4] + 2192)); + callArgs_311[1] = ((long) 11260); + callArgs_311[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_311); + break label_282; + } + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_285: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_285; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2216, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2212, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2208, (int) 6518); + long[] callArgs_312 = new long[3]; + callArgs_312[2] = ((long) (iL[4] + 2208)); + callArgs_312[1] = ((long) 12552); + callArgs_312[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_312); + break label_282; + } + label_286: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_313 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 148)); + int ciFuncId_313 = instance.table(0).requiredRef(ciTableIdx_313); + com.dylibso.chicory.runtime.Instance ciRefInstance_313 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_313), instance); + if (!ciRefInstance_313.type(ciRefInstance_313.functionType(ciFuncId_313)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_313 = new long[2]; + callArgs_313[1] = ((long) iL[3]); + callArgs_313[0] = ((long) iL[0]); + long[] callResult_313 = ciRefInstance_313.getMachine().call(ciFuncId_313, callArgs_313); + if (((int) callResult_313[0]) != 0) { + break label_286; + } + label_287: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_287; + } + iL[13] = 0; + label_288: while (true) { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3060); + long[] callArgs_314 = new long[3]; + callArgs_314[2] = ((long) (iL[4] + 3248)); + callArgs_314[1] = ((long) (iL[4] + 3168)); + callArgs_314[0] = ((long) (iL[4] + 2936)); + long[] callResult_314 = instance.getMachine().call(806, callArgs_314); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_314[0])) != 0) { + break label_282; + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) lL[0]); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[15] = memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 152); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 2232, (long) lL[0]); + label_289: { + label_290: { + label_291: { + iL[0] = (iL[13] + iL[0]); + int ciTableIdx_315 = (int) (iL[15]); + int ciFuncId_315 = instance.table(0).requiredRef(ciTableIdx_315); + com.dylibso.chicory.runtime.Instance ciRefInstance_315 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_315), instance); + if (!ciRefInstance_315.type(ciRefInstance_315.functionType(ciFuncId_315)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_315 = new long[4]; + callArgs_315[3] = ((long) ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 3248) & 0xFF)); + callArgs_315[2] = ((long) (iL[4] + 2232)); + callArgs_315[1] = ((long) iL[0]); + callArgs_315[0] = ((long) iL[14]); + long[] callResult_315 = ciRefInstance_315.getMachine().call(ciFuncId_315, callArgs_315); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_315[0])) != 0) { + break label_291; + } + iL[3] = 24987; + break label_290; + } + label_292: { + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_316 = (int) (memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 156)); + int ciFuncId_316 = instance.table(0).requiredRef(ciTableIdx_316); + com.dylibso.chicory.runtime.Instance ciRefInstance_316 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_316), instance); + if (!ciRefInstance_316.type(ciRefInstance_316.functionType(ciFuncId_316)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_316 = new long[2]; + callArgs_316[1] = ((long) iL[0]); + callArgs_316[0] = ((long) iL[14]); + long[] callResult_316 = ciRefInstance_316.getMachine().call(ciFuncId_316, callArgs_316); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_316[0])) != 0) { + break label_292; + } + iL[3] = 21093; + break label_290; + } + long[] callArgs_317 = new long[3]; + callArgs_317[2] = ((long) 12729); + callArgs_317[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)); + callArgs_317[0] = ((long) (iL[4] + 2936)); + long[] callResult_317 = instance.getMachine().call(804, callArgs_317); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_317[0])) != 0) { + break label_282; + } + label_293: { + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_318 = (int) (memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 160)); + int ciFuncId_318 = instance.table(0).requiredRef(ciTableIdx_318); + com.dylibso.chicory.runtime.Instance ciRefInstance_318 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_318), instance); + if (!ciRefInstance_318.type(ciRefInstance_318.functionType(ciFuncId_318)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_318 = new long[2]; + callArgs_318[1] = ((long) iL[0]); + callArgs_318[0] = ((long) iL[14]); + long[] callResult_318 = ciRefInstance_318.getMachine().call(ciFuncId_318, callArgs_318); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_318[0])) != 0) { + break label_293; + } + iL[3] = 21129; + break label_290; + } + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_319 = (int) (memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 164)); + int ciFuncId_319 = instance.table(0).requiredRef(ciTableIdx_319); + com.dylibso.chicory.runtime.Instance ciRefInstance_319 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_319), instance); + if (!ciRefInstance_319.type(ciRefInstance_319.functionType(ciFuncId_319)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_319 = new long[2]; + callArgs_319[1] = ((long) iL[0]); + callArgs_319[0] = ((long) iL[14]); + long[] callResult_319 = ciRefInstance_319.getMachine().call(ciFuncId_319, callArgs_319); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_319[0])) != 0) { + break label_289; + } + iL[3] = 25015; + } + long[] callArgs_320 = new long[3]; + callArgs_320[2] = ((long) 0); + callArgs_320[1] = ((long) iL[3]); + callArgs_320[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_320); + break label_282; + } + iL[13] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[13], iL[3]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_288; + } + break; + } + } + label_294: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_321 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 168)); + int ciFuncId_321 = instance.table(0).requiredRef(ciTableIdx_321); + com.dylibso.chicory.runtime.Instance ciRefInstance_321 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_321), instance); + if (!ciRefInstance_321.type(ciRefInstance_321.functionType(ciFuncId_321)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_321 = new long[1]; + callArgs_321[0] = ((long) iL[3]); + long[] callResult_321 = ciRefInstance_321.getMachine().call(ciFuncId_321, callArgs_321); + if (((int) callResult_321[0]) != 0) { + break label_294; + } + iL[3] = 0; + break label_281; + } + long[] callArgs_322 = new long[3]; + callArgs_322[2] = ((long) 0); + callArgs_322[1] = ((long) 24078); + callArgs_322[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_322); + break label_282; + } + long[] callArgs_323 = new long[3]; + callArgs_323[2] = ((long) 0); + callArgs_323[1] = ((long) 19846); + callArgs_323[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_323); + } + iL[3] = 1; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 10009; + break _hb; + } + } + label_295: { + label_296: { + label_297: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_324 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 128)); + int ciFuncId_324 = instance.table(0).requiredRef(ciTableIdx_324); + com.dylibso.chicory.runtime.Instance ciRefInstance_324 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_324), instance); + if (!ciRefInstance_324.type(ciRefInstance_324.functionType(ciFuncId_324)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_324 = new long[2]; + callArgs_324[1] = ((long) iL[0]); + callArgs_324[0] = ((long) iL[3]); + long[] callResult_324 = ciRefInstance_324.getMachine().call(ciFuncId_324, callArgs_324); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_324[0])) != 0) { + break label_297; + } + long[] callArgs_325 = new long[3]; + callArgs_325[2] = ((long) 0); + callArgs_325[1] = ((long) 23195); + callArgs_325[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_325); + break label_296; + } + label_298: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_326 = new long[3]; + callArgs_326[2] = ((long) (iL[4] + 3168)); + callArgs_326[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_326[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_326 = instance.getMachine().call(177, callArgs_326); + iL[3] = ((int) callResult_326[0]); + if (iL[3] != 0) { + break label_298; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2160, (int) 6151); + long[] callArgs_327 = new long[3]; + callArgs_327[2] = ((long) (iL[4] + 2160)); + callArgs_327[1] = ((long) 11260); + callArgs_327[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_327); + break label_296; + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_299: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[0], iL[3]) != 0) { + break label_299; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2184, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2180, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2176, (int) 6151); + long[] callArgs_328 = new long[3]; + callArgs_328[2] = ((long) (iL[4] + 2176)); + callArgs_328[1] = ((long) 12552); + callArgs_328[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_328); + break label_296; + } + label_300: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_329 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 132)); + int ciFuncId_329 = instance.table(0).requiredRef(ciTableIdx_329); + com.dylibso.chicory.runtime.Instance ciRefInstance_329 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_329), instance); + if (!ciRefInstance_329.type(ciRefInstance_329.functionType(ciFuncId_329)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_329 = new long[2]; + callArgs_329[1] = ((long) iL[0]); + callArgs_329[0] = ((long) iL[3]); + long[] callResult_329 = ciRefInstance_329.getMachine().call(ciFuncId_329, callArgs_329); + if (((int) callResult_329[0]) != 0) { + break label_300; + } + label_301: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_301; + } + iL[3] = 0; + label_302: while (true) { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3056); + memory.writeI32((int) ((iL[4] + 3168) + 15) < 0 ? ((iL[4] + 3168) + 15) : ((iL[4] + 3168) + 15) + 0, (int) 0); + memory.writeLong((int) ((iL[4] + 3168) + 8) < 0 ? ((iL[4] + 3168) + 8) : ((iL[4] + 3168) + 8) + 0, (long) 0L); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_330 = new long[3]; + callArgs_330[2] = ((long) (iL[4] + 3256)); + callArgs_330[1] = ((long) (iL[4] + 3168)); + callArgs_330[0] = ((long) (iL[4] + 2936)); + long[] callResult_330 = instance.getMachine().call(807, callArgs_330); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_330[0])) != 0) { + break label_296; + } + label_303: { + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_331 = (int) (memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 136)); + int ciFuncId_331 = instance.table(0).requiredRef(ciTableIdx_331); + com.dylibso.chicory.runtime.Instance ciRefInstance_331 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_331), instance); + if (!ciRefInstance_331.type(ciRefInstance_331.functionType(ciFuncId_331)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_331 = new long[4]; + callArgs_331[3] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3256)); + callArgs_331[2] = ((long) (iL[4] + 3168)); + callArgs_331[1] = ((long) (iL[3] + iL[13])); + callArgs_331[0] = ((long) iL[14]); + long[] callResult_331 = ciRefInstance_331.getMachine().call(ciFuncId_331, callArgs_331); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_331[0])) != 0) { + break label_303; + } + long[] callArgs_332 = new long[3]; + callArgs_332[2] = ((long) 0); + callArgs_332[1] = ((long) 18990); + callArgs_332[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_332); + break label_296; + } + iL[3] = (iL[3] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[3], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_302; + } + break; + } + } + label_304: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_333 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 140)); + int ciFuncId_333 = instance.table(0).requiredRef(ciTableIdx_333); + com.dylibso.chicory.runtime.Instance ciRefInstance_333 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_333), instance); + if (!ciRefInstance_333.type(ciRefInstance_333.functionType(ciFuncId_333)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_333 = new long[1]; + callArgs_333[0] = ((long) iL[3]); + long[] callResult_333 = ciRefInstance_333.getMachine().call(ciFuncId_333, callArgs_333); + if (((int) callResult_333[0]) != 0) { + break label_304; + } + iL[3] = 0; + break label_295; + } + long[] callArgs_334 = new long[3]; + callArgs_334[2] = ((long) 0); + callArgs_334[1] = ((long) 23230); + callArgs_334[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_334); + break label_296; + } + long[] callArgs_335 = new long[3]; + callArgs_335[2] = ((long) 0); + callArgs_335[1] = ((long) 19223); + callArgs_335[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_335); + } + iL[3] = 1; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 10009; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h2(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_92: { + label_93: { + label_94: { + label_95: { + label_96: { + label_97: { + label_98: { + int _d7 = func_804__h7(iL, lL, memory, instance); + if (_d7 == 1) + break label_92; + if (_d7 == 2) + break label_96; + if (_d7 == 3) + break label_97; + if (_d7 == 4) + break label_95; + if (_d7 == 5) + break label_94; + if (_d7 == 6) + break label_93; + if (_d7 >= 10000) { + _hs[0] = (_d7 - 10000); + break _hb; + } + } + iL[11] = 1; + label_203: { + iL[12] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12); + iL[10] = (iL[12] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[10], memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)) != 0) { + break label_203; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 164, (int) 2423); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 160, (int) 7656); + long[] callArgs_163 = new long[3]; + callArgs_163[2] = ((long) (iL[3] + 160)); + callArgs_163[1] = ((long) 10873); + callArgs_163[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_163); + { + _hs[0] = 10007; + break _hb; + } + } + lL[0] = (long) ((int) memory.read((int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4) + iL[12]) < 0 ? (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4) + iL[12]) : (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4) + iL[12]) + 0) & 0xFF); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[10]); + label_204: { + iL[12] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 36); + int ciTableIdx_164 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 556)); + int ciFuncId_164 = instance.table(0).requiredRef(ciTableIdx_164); + com.dylibso.chicory.runtime.Instance ciRefInstance_164 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_164), instance); + if (!ciRefInstance_164.type(ciRefInstance_164.functionType(ciFuncId_164)).typesMatch(instance.type(11))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_164 = new long[3]; + callArgs_164[2] = lL[0]; + callArgs_164[1] = ((long) iL[4]); + callArgs_164[0] = ((long) iL[12]); + long[] callResult_164 = ciRefInstance_164.getMachine().call(ciFuncId_164, callArgs_164); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_164[0])) != 0) { + break label_204; + } + long[] callArgs_165 = new long[3]; + callArgs_165[2] = ((long) 0); + callArgs_165[1] = ((long) 21720); + callArgs_165[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_165); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_166 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 256)); + int ciFuncId_166 = instance.table(0).requiredRef(ciTableIdx_166); + com.dylibso.chicory.runtime.Instance ciRefInstance_166 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_166), instance); + if (!ciRefInstance_166.type(ciRefInstance_166.functionType(ciFuncId_166)).typesMatch(instance.type(10))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_166 = new long[2]; + callArgs_166[1] = lL[0]; + callArgs_166[0] = ((long) iL[4]); + long[] callResult_166 = ciRefInstance_166.getMachine().call(ciFuncId_166, callArgs_166); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_166[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + long[] callArgs_167 = new long[3]; + callArgs_167[2] = ((long) 0); + callArgs_167[1] = ((long) 25733); + callArgs_167[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_167); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_168 = new long[3]; + callArgs_168[2] = ((long) 26807); + callArgs_168[1] = ((long) (iL[3] + 352)); + callArgs_168[0] = ((long) iL[0]); + long[] callResult_168 = instance.getMachine().call(826, callArgs_168); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_168[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 560); + iL[10] = ((iL[3] + 352) + 8); + memory.writeLong((int) ((iL[3] + 184) + 8) < 0 ? ((iL[3] + 184) + 8) : ((iL[3] + 184) + 8) + 0, (long) memory.readLong((int) iL[10] < 0 ? iL[10] : iL[10] + 0)); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 184, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352)); + label_205: { + int ciTableIdx_169 = (int) (iL[12]); + int ciFuncId_169 = instance.table(0).requiredRef(ciTableIdx_169); + com.dylibso.chicory.runtime.Instance ciRefInstance_169 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_169), instance); + if (!ciRefInstance_169.type(ciRefInstance_169.functionType(ciFuncId_169)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_169 = new long[3]; + callArgs_169[2] = ((long) (iL[3] + 184)); + callArgs_169[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_169[0] = ((long) iL[4]); + long[] callResult_169 = ciRefInstance_169.getMachine().call(ciFuncId_169, callArgs_169); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_169[0])) != 0) { + break label_205; + } + iL[4] = 21753; + { + _hs[0] = 10030; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 268); + memory.writeLong((int) ((iL[3] + 168) + 8) < 0 ? ((iL[3] + 168) + 8) : ((iL[3] + 168) + 8) + 0, (long) memory.readLong((int) iL[10] < 0 ? iL[10] : iL[10] + 0)); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 168, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352)); + int ciTableIdx_170 = (int) (iL[12]); + int ciFuncId_170 = instance.table(0).requiredRef(ciTableIdx_170); + com.dylibso.chicory.runtime.Instance ciRefInstance_170 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_170), instance); + if (!ciRefInstance_170.type(ciRefInstance_170.functionType(ciFuncId_170)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_170 = new long[2]; + callArgs_170[1] = ((long) (iL[3] + 168)); + callArgs_170[0] = ((long) iL[4]); + long[] callResult_170 = ciRefInstance_170.getMachine().call(ciFuncId_170, callArgs_170); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_170[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25704; + { + _hs[0] = 10030; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_171 = new long[8]; + callArgs_171[7] = ((long) 0); + callArgs_171[6] = ((long) 7265); + callArgs_171[5] = ((long) 2411); + callArgs_171[4] = ((long) 6877); + callArgs_171[3] = ((long) (iL[3] + 336)); + callArgs_171[2] = ((long) (iL[3] + 348)); + callArgs_171[1] = ((long) (iL[3] + 352)); + callArgs_171[0] = ((long) iL[0]); + long[] callResult_171 = instance.getMachine().call(827, callArgs_171); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_171[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + label_206: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_172 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 572)); + int ciFuncId_172 = instance.table(0).requiredRef(ciTableIdx_172); + com.dylibso.chicory.runtime.Instance ciRefInstance_172 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_172), instance); + if (!ciRefInstance_172.type(ciRefInstance_172.functionType(ciFuncId_172)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_172 = new long[5]; + callArgs_172[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_172[3] = lL[0]; + callArgs_172[2] = ((long) iL[4]); + callArgs_172[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_172[0] = ((long) iL[12]); + long[] callResult_172 = ciRefInstance_172.getMachine().call(ciFuncId_172, callArgs_172); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_172[0])) != 0) { + break label_206; + } + iL[4] = 21521; + { + _hs[0] = 10031; + break _hb; + } + } + iL[12] = (int) lL[0]; + iL[10] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[14] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[13] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + label_207: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_207; + } + int ciTableIdx_173 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 248)); + int ciFuncId_173 = instance.table(0).requiredRef(ciTableIdx_173); + com.dylibso.chicory.runtime.Instance ciRefInstance_173 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_173), instance); + if (!ciRefInstance_173.type(ciRefInstance_173.functionType(ciFuncId_173)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_173 = new long[4]; + callArgs_173[3] = ((long) iL[13]); + callArgs_173[2] = ((long) iL[4]); + callArgs_173[1] = ((long) iL[12]); + callArgs_173[0] = ((long) iL[10]); + long[] callResult_173 = ciRefInstance_173.getMachine().call(ciFuncId_173, callArgs_173); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_173[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25860; + { + _hs[0] = 10031; + break _hb; + } + } + int ciTableIdx_174 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 244)); + int ciFuncId_174 = instance.table(0).requiredRef(ciTableIdx_174); + com.dylibso.chicory.runtime.Instance ciRefInstance_174 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_174), instance); + if (!ciRefInstance_174.type(ciRefInstance_174.functionType(ciFuncId_174)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_174 = new long[3]; + callArgs_174[2] = ((long) iL[13]); + callArgs_174[1] = ((long) iL[12]); + callArgs_174[0] = ((long) iL[10]); + long[] callResult_174 = ciRefInstance_174.getMachine().call(ciFuncId_174, callArgs_174); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_174[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25823; + { + _hs[0] = 10031; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_175 = new long[8]; + callArgs_175[7] = ((long) (iL[3] + 296)); + callArgs_175[6] = ((long) 7265); + callArgs_175[5] = ((long) 2411); + callArgs_175[4] = ((long) 6877); + callArgs_175[3] = ((long) (iL[3] + 336)); + callArgs_175[2] = ((long) (iL[3] + 348)); + callArgs_175[1] = ((long) (iL[3] + 352)); + callArgs_175[0] = ((long) iL[0]); + long[] callResult_175 = instance.getMachine().call(827, callArgs_175); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_175[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + label_208: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_176 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 564)); + int ciFuncId_176 = instance.table(0).requiredRef(ciTableIdx_176); + com.dylibso.chicory.runtime.Instance ciRefInstance_176 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_176), instance); + if (!ciRefInstance_176.type(ciRefInstance_176.functionType(ciFuncId_176)).typesMatch(instance.type(15))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_176 = new long[6]; + callArgs_176[5] = (long) ((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 296) & 0xFF); + callArgs_176[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_176[3] = lL[0]; + callArgs_176[2] = ((long) iL[4]); + callArgs_176[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_176[0] = ((long) iL[12]); + long[] callResult_176 = ciRefInstance_176.getMachine().call(ciFuncId_176, callArgs_176); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_176[0])) != 0) { + break label_208; + } + iL[4] = 22584; + { + _hs[0] = 10032; + break _hb; + } + } + iL[12] = (int) lL[0]; + iL[10] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[14] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[13] = ((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 296) & 0xFF); + iL[15] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + label_209: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_209; + } + int ciTableIdx_177 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 252)); + int ciFuncId_177 = instance.table(0).requiredRef(ciTableIdx_177); + com.dylibso.chicory.runtime.Instance ciRefInstance_177 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_177), instance); + if (!ciRefInstance_177.type(ciRefInstance_177.functionType(ciFuncId_177)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_177 = new long[5]; + callArgs_177[4] = ((long) iL[13]); + callArgs_177[3] = ((long) iL[15]); + callArgs_177[2] = ((long) iL[4]); + callArgs_177[1] = ((long) iL[12]); + callArgs_177[0] = ((long) iL[10]); + long[] callResult_177 = ciRefInstance_177.getMachine().call(ciFuncId_177, callArgs_177); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_177[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25903; + { + _hs[0] = 10032; + break _hb; + } + } + int ciTableIdx_178 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 248)); + int ciFuncId_178 = instance.table(0).requiredRef(ciTableIdx_178); + com.dylibso.chicory.runtime.Instance ciRefInstance_178 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_178), instance); + if (!ciRefInstance_178.type(ciRefInstance_178.functionType(ciFuncId_178)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_178 = new long[4]; + callArgs_178[3] = ((long) iL[13]); + callArgs_178[2] = ((long) iL[15]); + callArgs_178[1] = ((long) iL[12]); + callArgs_178[0] = ((long) iL[10]); + long[] callResult_178 = ciRefInstance_178.getMachine().call(ciFuncId_178, callArgs_178); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_178[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25860; + { + _hs[0] = 10032; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_179 = new long[8]; + callArgs_179[7] = ((long) (iL[3] + 296)); + callArgs_179[6] = ((long) 7240); + callArgs_179[5] = ((long) 2398); + callArgs_179[4] = ((long) 6861); + callArgs_179[3] = ((long) (iL[3] + 336)); + callArgs_179[2] = ((long) (iL[3] + 348)); + callArgs_179[1] = ((long) (iL[3] + 352)); + callArgs_179[0] = ((long) iL[0]); + long[] callResult_179 = instance.getMachine().call(827, callArgs_179); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_179[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + label_210: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_180 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 568)); + int ciFuncId_180 = instance.table(0).requiredRef(ciTableIdx_180); + com.dylibso.chicory.runtime.Instance ciRefInstance_180 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_180), instance); + if (!ciRefInstance_180.type(ciRefInstance_180.functionType(ciFuncId_180)).typesMatch(instance.type(15))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_180 = new long[6]; + callArgs_180[5] = (long) ((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 296) & 0xFF); + callArgs_180[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_180[3] = lL[0]; + callArgs_180[2] = ((long) iL[4]); + callArgs_180[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_180[0] = ((long) iL[12]); + long[] callResult_180 = ciRefInstance_180.getMachine().call(ciFuncId_180, callArgs_180); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_180[0])) != 0) { + break label_210; + } + iL[4] = 22548; + { + _hs[0] = 10033; + break _hb; + } + } + iL[12] = (int) lL[0]; + iL[10] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[14] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[13] = ((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 296) & 0xFF); + iL[15] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + label_211: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_211; + } + int ciTableIdx_181 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 252)); + int ciFuncId_181 = instance.table(0).requiredRef(ciTableIdx_181); + com.dylibso.chicory.runtime.Instance ciRefInstance_181 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_181), instance); + if (!ciRefInstance_181.type(ciRefInstance_181.functionType(ciFuncId_181)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_181 = new long[5]; + callArgs_181[4] = ((long) iL[13]); + callArgs_181[3] = ((long) iL[15]); + callArgs_181[2] = ((long) iL[4]); + callArgs_181[1] = ((long) iL[12]); + callArgs_181[0] = ((long) iL[10]); + long[] callResult_181 = ciRefInstance_181.getMachine().call(ciFuncId_181, callArgs_181); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_181[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25903; + { + _hs[0] = 10033; + break _hb; + } + } + int ciTableIdx_182 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 248)); + int ciFuncId_182 = instance.table(0).requiredRef(ciTableIdx_182); + com.dylibso.chicory.runtime.Instance ciRefInstance_182 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_182), instance); + if (!ciRefInstance_182.type(ciRefInstance_182.functionType(ciFuncId_182)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_182 = new long[4]; + callArgs_182[3] = ((long) iL[13]); + callArgs_182[2] = ((long) iL[15]); + callArgs_182[1] = ((long) iL[12]); + callArgs_182[0] = ((long) iL[10]); + long[] callResult_182 = ciRefInstance_182.getMachine().call(ciFuncId_182, callArgs_182); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_182[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25860; + { + _hs[0] = 10033; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_183 = new long[8]; + callArgs_183[7] = ((long) 0); + callArgs_183[6] = ((long) 7265); + callArgs_183[5] = ((long) 2411); + callArgs_183[4] = ((long) 6877); + callArgs_183[3] = ((long) (iL[3] + 336)); + callArgs_183[2] = ((long) (iL[3] + 348)); + callArgs_183[1] = ((long) (iL[3] + 352)); + callArgs_183[0] = ((long) iL[0]); + long[] callResult_183 = instance.getMachine().call(827, callArgs_183); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_183[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + label_212: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_184 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 576)); + int ciFuncId_184 = instance.table(0).requiredRef(ciTableIdx_184); + com.dylibso.chicory.runtime.Instance ciRefInstance_184 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_184), instance); + if (!ciRefInstance_184.type(ciRefInstance_184.functionType(ciFuncId_184)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_184 = new long[5]; + callArgs_184[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_184[3] = lL[0]; + callArgs_184[2] = ((long) iL[12]); + callArgs_184[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_184[0] = ((long) iL[4]); + long[] callResult_184 = ciRefInstance_184.getMachine().call(ciFuncId_184, callArgs_184); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_184[0])) != 0) { + break label_212; + } + long[] callArgs_185 = new long[3]; + callArgs_185[2] = ((long) 0); + callArgs_185[1] = ((long) 21789); + callArgs_185[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_185); + { + _hs[0] = 10007; + break _hb; + } + } + long[] callArgs_186 = new long[5]; + callArgs_186[4] = ((long) 0); + callArgs_186[3] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_186[2] = ((long) iL[12]); + callArgs_186[1] = lL[0]; + callArgs_186[0] = ((long) iL[0]); + long[] callResult_186 = instance.getMachine().call(829, callArgs_186); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_186[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + { + _hs[0] = 10007; + break _hb; + } + } + label_213: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_187 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 352)); + int ciFuncId_187 = instance.table(0).requiredRef(ciTableIdx_187); + com.dylibso.chicory.runtime.Instance ciRefInstance_187 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_187), instance); + if (!ciRefInstance_187.type(ciRefInstance_187.functionType(ciFuncId_187)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_187 = new long[2]; + callArgs_187[1] = ((long) iL[4]); + callArgs_187[0] = ((long) iL[12]); + long[] callResult_187 = ciRefInstance_187.getMachine().call(ciFuncId_187, callArgs_187); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_187[0])) != 0) { + break label_213; + } + long[] callArgs_188 = new long[3]; + callArgs_188[2] = ((long) 0); + callArgs_188[1] = ((long) 20870); + callArgs_188[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_188); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_189 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_189 = instance.table(0).requiredRef(ciTableIdx_189); + com.dylibso.chicory.runtime.Instance ciRefInstance_189 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_189), instance); + if (!ciRefInstance_189.type(ciRefInstance_189.functionType(ciFuncId_189)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_189 = new long[1]; + callArgs_189[0] = ((long) iL[4]); + long[] callResult_189 = ciRefInstance_189.getMachine().call(ciFuncId_189, callArgs_189); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_189[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + long[] callArgs_190 = new long[3]; + callArgs_190[2] = ((long) 0); + callArgs_190[1] = ((long) 25128); + callArgs_190[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_190); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1174__h1(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_19: { + label_20: { + label_21: { + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) 1); + callArgs_13[0] = ((long) iL[0]); + long[] callResult_13 = instance.getMachine().call(1154, callArgs_13); + iL[5] = ((int) callResult_13[0]); + switch((iL[5] + -90)) { + case 0: + { + break label_19; + } + case 1: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 2: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 3: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 4: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 5: + { + break label_20; + } + case 6: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 7: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 8: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 9: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 10: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 11: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 12: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 13: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 14: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 15: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 16: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 17: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 18: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 19: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 20: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 21: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 22: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 23: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 24: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 25: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 26: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 27: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 28: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 29: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 30: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 31: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 32: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 33: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 34: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 35: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 36: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 37: + { + break _hb; + } + case 38: + { + { + _hs[0] = 10000; + break _hb; + } + } + default: + { + break label_21; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(68, iL[5]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + iL[3] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[5] = (iL[4] + (iL[3] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeByte((int) (iL[5] + 36) < 0 ? (iL[5] + 36) : (iL[5] + 36) + 0, (byte) (0)); + iL[5] = (iL[3] ^ 1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[5])); + iL[5] = (iL[4] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[3])); + memory.writeByte((int) (iL[5] + 36) < 0 ? (iL[5] + 36) : (iL[5] + 36) + 0, (byte) (0)); + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) 184); + long[] callResult_14 = instance.getMachine().call(1776, callArgs_14); + iL[3] = ((int) callResult_14[0]); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 4, (long) 0L); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 32, (int) 8); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (long) 0L); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (int) 57720); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 152)); + memory.writeLong((int) (iL[3] + 20) < 0 ? (iL[3] + 20) : (iL[3] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 152) + 8) < 0 ? ((iL[2] + 152) + 8) : ((iL[2] + 152) + 8) + 0)); + memory.writeI32((int) (iL[3] + 28) < 0 ? (iL[3] + 28) : (iL[3] + 28) + 0, (int) memory.readInt((int) (iL[2] + 168) < 0 ? (iL[2] + 168) : (iL[2] + 168) + 0)); + memory.writeLong((int) (iL[3] + 41) < 0 ? (iL[3] + 41) : (iL[3] + 41) + 0, (long) 0L); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) (iL[3] + 52)); + long[] callResult_15 = instance.getMachine().call(154, callArgs_15); + memory.writeLong((int) (iL[3] + 120) < 0 ? (iL[3] + 120) : (iL[3] + 120) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 112) < 0 ? (iL[3] + 112) : (iL[3] + 112) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 104) < 0 ? (iL[3] + 104) : (iL[3] + 104) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 96) < 0 ? (iL[3] + 96) : (iL[3] + 96) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 88) < 0 ? (iL[3] + 88) : (iL[3] + 88) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 132) < 0 ? (iL[3] + 132) : (iL[3] + 132) + 0, (long) 0L); + memory.writeI32((int) (iL[3] + 128) < 0 ? (iL[3] + 128) : (iL[3] + 128) + 0, (int) 1065353216); + memory.writeLong((int) (iL[3] + 140) < 0 ? (iL[3] + 140) : (iL[3] + 140) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 152) < 0 ? (iL[3] + 152) : (iL[3] + 152) + 0, (long) 0L); + memory.writeI32((int) (iL[3] + 148) < 0 ? (iL[3] + 148) : (iL[3] + 148) + 0, (int) 1065353216); + memory.writeLong((int) (iL[3] + 160) < 0 ? (iL[3] + 160) : (iL[3] + 160) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 168) < 0 ? (iL[3] + 168) : (iL[3] + 168) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 176) < 0 ? (iL[3] + 176) : (iL[3] + 176) + 0, (long) 0L); + label_22: { + iL[5] = (iL[3] + 36); + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) iL[5]); + callArgs_16[0] = ((long) iL[0]); + long[] callResult_16 = instance.getMachine().call(1178, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_16[0])) != 0) { + break label_22; + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) iL[5]); + callArgs_17[0] = ((long) iL[0]); + long[] callResult_17 = instance.getMachine().call(1179, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_17[0])) != 0) { + break label_22; + } + iL[5] = iL[1]; + label_23: { + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_23; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 8, (int) iL[4]); + iL[5] = (iL[4] + 4); + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) iL[3]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[3]); + iL[7] = (iL[1] + 8); + { + _hs[0] = 10003; + break _hb; + } + } + int ciTableIdx_18 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_18 = instance.table(0).requiredRef(ciTableIdx_18); + com.dylibso.chicory.runtime.Instance ciRefInstance_18 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_18), instance); + if (!ciRefInstance_18.type(ciRefInstance_18.functionType(ciFuncId_18)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) iL[3]); + ciRefInstance_18.getMachine().call(ciFuncId_18, callArgs_18); + iL[3] = 1; + { + _hs[0] = 10001; + break _hb; + } + } + iL[3] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[5] = (iL[4] + (iL[3] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeByte((int) (iL[5] + 36) < 0 ? (iL[5] + 36) : (iL[5] + 36) + 0, (byte) (0)); + iL[5] = (iL[3] ^ 1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[5])); + iL[5] = (iL[4] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[3])); + memory.writeByte((int) (iL[5] + 36) < 0 ? (iL[5] + 36) : (iL[5] + 36) + 0, (byte) (0)); + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) 184); + long[] callResult_19 = instance.getMachine().call(1776, callArgs_19); + iL[3] = ((int) callResult_19[0]); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 4, (long) 0L); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 32, (int) 27); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (long) 0L); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (int) 57840); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 152)); + memory.writeLong((int) (iL[3] + 20) < 0 ? (iL[3] + 20) : (iL[3] + 20) + 0, (long) memory.readLong((int) (iL[2] + 160) < 0 ? (iL[2] + 160) : (iL[2] + 160) + 0)); + memory.writeI32((int) (iL[3] + 28) < 0 ? (iL[3] + 28) : (iL[3] + 28) + 0, (int) memory.readInt((int) (iL[2] + 168) < 0 ? (iL[2] + 168) : (iL[2] + 168) + 0)); + memory.writeLong((int) (iL[3] + 41) < 0 ? (iL[3] + 41) : (iL[3] + 41) + 0, (long) 0L); + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) (iL[3] + 52)); + long[] callResult_20 = instance.getMachine().call(154, callArgs_20); + memory.writeLong((int) (iL[3] + 120) < 0 ? (iL[3] + 120) : (iL[3] + 120) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 112) < 0 ? (iL[3] + 112) : (iL[3] + 112) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 104) < 0 ? (iL[3] + 104) : (iL[3] + 104) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 96) < 0 ? (iL[3] + 96) : (iL[3] + 96) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 88) < 0 ? (iL[3] + 88) : (iL[3] + 88) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 132) < 0 ? (iL[3] + 132) : (iL[3] + 132) + 0, (long) 0L); + memory.writeI32((int) (iL[3] + 128) < 0 ? (iL[3] + 128) : (iL[3] + 128) + 0, (int) 1065353216); + memory.writeLong((int) (iL[3] + 140) < 0 ? (iL[3] + 140) : (iL[3] + 140) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 152) < 0 ? (iL[3] + 152) : (iL[3] + 152) + 0, (long) 0L); + memory.writeI32((int) (iL[3] + 148) < 0 ? (iL[3] + 148) : (iL[3] + 148) + 0, (int) 1065353216); + memory.writeLong((int) (iL[3] + 160) < 0 ? (iL[3] + 160) : (iL[3] + 160) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 168) < 0 ? (iL[3] + 168) : (iL[3] + 168) + 0, (long) 0L); + memory.writeLong((int) (iL[3] + 176) < 0 ? (iL[3] + 176) : (iL[3] + 176) + 0, (long) 0L); + label_24: { + iL[5] = (iL[3] + 36); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) iL[5]); + callArgs_21[0] = ((long) iL[0]); + long[] callResult_21 = instance.getMachine().call(1178, callArgs_21); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_21[0])) != 0) { + break label_24; + } + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) iL[5]); + callArgs_22[0] = ((long) iL[0]); + long[] callResult_22 = instance.getMachine().call(1179, callArgs_22); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_22[0])) != 0) { + break label_24; + } + iL[5] = iL[1]; + label_25: { + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_25; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 8, (int) iL[4]); + iL[5] = (iL[4] + 4); + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (int) iL[3]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[3]); + iL[7] = (iL[1] + 8); + { + _hs[0] = 10003; + break _hb; + } + } + int ciTableIdx_23 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_23 = instance.table(0).requiredRef(ciTableIdx_23); + com.dylibso.chicory.runtime.Instance ciRefInstance_23 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_23), instance); + if (!ciRefInstance_23.type(ciRefInstance_23.functionType(ciFuncId_23)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) iL[3]); + ciRefInstance_23.getMachine().call(ciFuncId_23, callArgs_23); + iL[3] = 1; + { + _hs[0] = 10001; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[3] = (iL[4] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[3] = 1; + iL[6] = (iL[5] ^ 1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[6])); + iL[4] = (iL[4] + (iL[6] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) (iL[5])); + memory.writeByte((int) (iL[4] + 36) < 0 ? (iL[4] + 36) : (iL[4] + 36) + 0, (byte) (0)); + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) 216); + long[] callResult_24 = instance.getMachine().call(1776, callArgs_24); + iL[8] = ((int) callResult_24[0]); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 4, (long) 0L); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 32, (int) 22); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 36, (long) 0L); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) 57960); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 152)); + memory.writeLong((int) (iL[8] + 20) < 0 ? (iL[8] + 20) : (iL[8] + 20) + 0, (long) memory.readLong((int) (iL[2] + 160) < 0 ? (iL[2] + 160) : (iL[2] + 160) + 0)); + memory.writeI32((int) (iL[8] + 28) < 0 ? (iL[8] + 28) : (iL[8] + 28) + 0, (int) memory.readInt((int) (iL[2] + 168) < 0 ? (iL[2] + 168) : (iL[2] + 168) + 0)); + memory.writeLong((int) (iL[8] + 41) < 0 ? (iL[8] + 41) : (iL[8] + 41) + 0, (long) 0L); + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) (iL[8] + 52)); + long[] callResult_25 = instance.getMachine().call(154, callArgs_25); + memory.writeLong((int) (iL[8] + 120) < 0 ? (iL[8] + 120) : (iL[8] + 120) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 112) < 0 ? (iL[8] + 112) : (iL[8] + 112) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 104) < 0 ? (iL[8] + 104) : (iL[8] + 104) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 96) < 0 ? (iL[8] + 96) : (iL[8] + 96) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 88) < 0 ? (iL[8] + 88) : (iL[8] + 88) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 132) < 0 ? (iL[8] + 132) : (iL[8] + 132) + 0, (long) 0L); + memory.writeI32((int) (iL[8] + 128) < 0 ? (iL[8] + 128) : (iL[8] + 128) + 0, (int) 1065353216); + memory.writeLong((int) (iL[8] + 140) < 0 ? (iL[8] + 140) : (iL[8] + 140) + 0, (long) 0L); + iL[9] = (iL[8] + 152); + memory.writeLong((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (long) 0L); + memory.writeI32((int) (iL[8] + 148) < 0 ? (iL[8] + 148) : (iL[8] + 148) + 0, (int) 1065353216); + memory.writeLong((int) (iL[8] + 160) < 0 ? (iL[8] + 160) : (iL[8] + 160) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 168) < 0 ? (iL[8] + 168) : (iL[8] + 168) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 176) < 0 ? (iL[8] + 176) : (iL[8] + 176) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 184) < 0 ? (iL[8] + 184) : (iL[8] + 184) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 192) < 0 ? (iL[8] + 192) : (iL[8] + 192) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 200) < 0 ? (iL[8] + 200) : (iL[8] + 200) + 0, (long) 0L); + memory.writeLong((int) (iL[8] + 208) < 0 ? (iL[8] + 208) : (iL[8] + 208) + 0, (long) 0L); + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) (iL[8] + 36)); + callArgs_26[0] = ((long) iL[0]); + long[] callResult_26 = instance.getMachine().call(1178, callArgs_26); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_26[0])) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + iL[3] = 1; + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) (iL[8] + 48)); + callArgs_27[0] = ((long) iL[0]); + long[] callResult_27 = instance.getMachine().call(1180, callArgs_27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_27[0])) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + iL[7] = (iL[1] + 8); + label_26: { + label_27: while (true) { + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) 0); + callArgs_28[0] = ((long) iL[0]); + long[] callResult_28 = instance.getMachine().call(1154, callArgs_28); + iL[5] = ((int) callResult_28[0]); + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) 1); + callArgs_29[0] = ((long) iL[0]); + long[] callResult_29 = instance.getMachine().call(1154, callArgs_29); + iL[3] = ((int) callResult_29[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(30, iL[5]) != 0) { + break label_26; + } + label_28: { + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) iL[3]); + long[] callResult_30 = instance.getMachine().call(1156, callArgs_30); + if (((int) callResult_30[0]) != 0) { + break label_28; + } + label_29: { + switch((iL[3] + -90)) { + case 0: + { + break label_28; + } + case 1: + { + break label_26; + } + case 2: + { + break label_26; + } + case 3: + { + break label_26; + } + case 4: + { + break label_26; + } + case 5: + { + break label_28; + } + case 6: + { + break label_26; + } + case 7: + { + break label_26; + } + case 8: + { + break label_26; + } + case 9: + { + break label_26; + } + case 10: + { + break label_26; + } + case 11: + { + break label_26; + } + case 12: + { + break label_26; + } + case 13: + { + break label_26; + } + case 14: + { + break label_26; + } + case 15: + { + break label_26; + } + case 16: + { + break label_26; + } + case 17: + { + break label_26; + } + case 18: + { + break label_26; + } + case 19: + { + break label_26; + } + case 20: + { + break label_26; + } + case 21: + { + break label_26; + } + case 22: + { + break label_26; + } + case 23: + { + break label_26; + } + case 24: + { + break label_26; + } + case 25: + { + break label_26; + } + case 26: + { + break label_26; + } + case 27: + { + break label_26; + } + case 28: + { + break label_26; + } + case 29: + { + break label_26; + } + case 30: + { + break label_26; + } + case 31: + { + break label_26; + } + case 32: + { + break label_26; + } + case 33: + { + break label_26; + } + case 34: + { + break label_26; + } + case 35: + { + break label_26; + } + case 36: + { + break label_26; + } + case 37: + { + break label_28; + } + case 38: + { + break label_28; + } + default: + { + break label_29; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(68, iL[3]) != 0) { + break label_26; + } + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 216, (int) 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 208, (long) 0L); + long[] callArgs_31 = new long[2]; + callArgs_31[1] = ((long) (iL[2] + 208)); + callArgs_31[0] = ((long) iL[0]); + long[] callResult_31 = instance.getMachine().call(1174, callArgs_31); + iL[10] = ((int) callResult_31[0]); + iL[3] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 208); + label_30: { + label_31: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[10]) != 0) { + break label_31; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_30; + } + iL[11] = memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0); + iL[12] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 216); + iL[5] = iL[3]; + label_32: while (true) { + iL[4] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 4); + label_33: { + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 212), iL[3]) != 0) { + break label_34; + } + iL[13] = iL[4]; + iL[6] = iL[4]; + label_35: { + iL[14] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[14]) != 0) { + break label_35; + } + memory.writeI32((int) iL[14] < 0 ? iL[14] : iL[14] + 4, (int) iL[4]); + iL[6] = memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 4); + iL[13] = iL[3]; + } + label_36: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[6]) != 0) { + break label_36; + } + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 8, (int) iL[14]); + iL[3] = iL[13]; + break label_33; + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 212, (int) iL[14]); + iL[3] = iL[13]; + break label_33; + } + iL[3] = 0; + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 212, (int) 0); + } + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 4, (long) 0L); + iL[6] = iL[1]; + label_37: { + iL[13] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_37; + } + memory.writeI32((int) iL[5] < 0 ? iL[5] : iL[5] + 8, (int) iL[13]); + iL[6] = (iL[13] + 4); + } + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (int) iL[5]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[5]); + iL[12] = (iL[12] + -1); + iL[11] = (iL[11] + 1); + iL[5] = iL[4]; + if (iL[4] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_32; + } + break; + } + memory.writeI32((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (int) iL[11]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 216, (int) iL[12]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 208, (int) iL[3]); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_30; + } + label_38: while (true) { + iL[5] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 4); + int ciTableIdx_32 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_32 = instance.table(0).requiredRef(ciTableIdx_32); + com.dylibso.chicory.runtime.Instance ciRefInstance_32 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_32), instance); + if (!ciRefInstance_32.type(ciRefInstance_32.functionType(ciFuncId_32)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_32 = new long[1]; + callArgs_32[0] = ((long) iL[3]); + ciRefInstance_32.getMachine().call(ciFuncId_32, callArgs_32); + iL[3] = iL[5]; + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_38; + } + break; + } + } + iL[3] = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, iL[10]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_27; + } + { + _hs[0] = 10004; + break _hb; + } + } + } + iL[3] = 1; + long[] callArgs_33 = new long[2]; + callArgs_33[1] = ((long) 30); + callArgs_33[0] = ((long) iL[0]); + long[] callResult_33 = instance.getMachine().call(1160, callArgs_33); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_33[0])) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + label_39: { + long[] callArgs_34 = new long[2]; + callArgs_34[1] = ((long) 49); + callArgs_34[0] = ((long) iL[0]); + long[] callResult_34 = instance.getMachine().call(1158, callArgs_34); + if (((int) callResult_34[0]) != 0) { + break label_39; + } + long[] callArgs_35 = new long[2]; + callArgs_35[1] = ((long) 13962); + callArgs_35[0] = ((long) (iL[2] + 120)); + long[] callResult_35 = instance.getMachine().call(1167, callArgs_35); + iL[5] = ((int) callResult_35[0]); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 148, (int) 1); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 144, (int) iL[5]); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 8, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 144)); + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) (iL[2] + 8)); + callArgs_36[0] = ((long) (iL[2] + 208)); + long[] callResult_36 = instance.getMachine().call(1168, callArgs_36); + iL[4] = ((int) callResult_36[0]); + long[] callArgs_37 = new long[3]; + callArgs_37[2] = ((long) 30604); + callArgs_37[1] = ((long) iL[4]); + callArgs_37[0] = ((long) iL[0]); + long[] callResult_37 = instance.getMachine().call(1163, callArgs_37); + iL[3] = ((int) callResult_37[0]); + long[] callArgs_38 = new long[1]; + callArgs_38[0] = ((long) iL[4]); + long[] callResult_38 = instance.getMachine().call(1169, callArgs_38); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 11), -1) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + long[] callArgs_39 = new long[1]; + callArgs_39[0] = ((long) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + instance.getMachine().call(1777, callArgs_39); + { + _hs[0] = 10004; + break _hb; + } + } + iL[3] = 1; + long[] callArgs_40 = new long[2]; + callArgs_40[1] = ((long) iL[9]); + callArgs_40[0] = ((long) iL[0]); + long[] callResult_40 = instance.getMachine().call(1173, callArgs_40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_40[0])) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + long[] callArgs_41 = new long[2]; + callArgs_41[1] = ((long) iL[0]); + callArgs_41[0] = ((long) (iL[2] + 208)); + instance.getMachine().call(1153, callArgs_41); + memory.writeI32((int) (iL[8] + 180) < 0 ? (iL[8] + 180) : (iL[8] + 180) + 0, (int) memory.readInt((int) (iL[2] + 224) < 0 ? (iL[2] + 224) : (iL[2] + 224) + 0)); + memory.writeLong((int) (iL[8] + 172) < 0 ? (iL[8] + 172) : (iL[8] + 172) + 0, (long) memory.readLong((int) (iL[2] + 216) < 0 ? (iL[2] + 216) : (iL[2] + 216) + 0)); + memory.writeLong((int) (iL[8] + 164) < 0 ? (iL[8] + 164) : (iL[8] + 164) + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 208)); + iL[3] = 1; + long[] callArgs_42 = new long[2]; + callArgs_42[1] = ((long) 44); + callArgs_42[0] = ((long) iL[0]); + long[] callResult_42 = instance.getMachine().call(1160, callArgs_42); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_42[0])) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + label_40: { + long[] callArgs_43 = new long[2]; + callArgs_43[1] = ((long) 86); + callArgs_43[0] = ((long) iL[0]); + long[] callResult_43 = instance.getMachine().call(1159, callArgs_43); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_43[0])) != 0) { + break label_40; + } + iL[3] = 1; + long[] callArgs_44 = new long[2]; + callArgs_44[1] = ((long) (iL[8] + 184)); + callArgs_44[0] = ((long) iL[0]); + long[] callResult_44 = instance.getMachine().call(1173, callArgs_44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_44[0])) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + iL[3] = 1; + long[] callArgs_45 = new long[2]; + callArgs_45[1] = ((long) 44); + callArgs_45[0] = ((long) iL[0]); + long[] callResult_45 = instance.getMachine().call(1160, callArgs_45); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_45[0])) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + } + long[] callArgs_46 = new long[2]; + callArgs_46[1] = ((long) iL[0]); + callArgs_46[0] = ((long) (iL[2] + 208)); + instance.getMachine().call(1153, callArgs_46); + memory.writeI32((int) (iL[8] + 212) < 0 ? (iL[8] + 212) : (iL[8] + 212) + 0, (int) memory.readInt((int) (iL[2] + 224) < 0 ? (iL[2] + 224) : (iL[2] + 224) + 0)); + memory.writeLong((int) (iL[8] + 204) < 0 ? (iL[8] + 204) : (iL[8] + 204) + 0, (long) memory.readLong((int) (iL[2] + 216) < 0 ? (iL[2] + 216) : (iL[2] + 216) + 0)); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 196, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 208)); + iL[3] = iL[1]; + label_41: { + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_41; + } + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 8, (int) iL[5]); + iL[3] = (iL[5] + 4); + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (int) iL[8]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[8]); + { + _hs[0] = 10003; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1176__h2(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_39: { + label_40: { + label_41: { + label_42: { + label_43: { + label_44: { + label_45: { + label_46: { + label_47: { + label_48: { + label_49: { + int _d5 = func_1176__h5(iL, memory, instance); + if (_d5 == 1) + break label_41; + if (_d5 == 2) + break label_40; + if (_d5 == 3) + break label_43; + if (_d5 == 4) + break label_39; + if (_d5 == 5) + break label_47; + if (_d5 == 6) + break label_46; + if (_d5 == 7) + break label_45; + if (_d5 == 8) + break label_48; + if (_d5 == 9) + break label_44; + if (_d5 == 10) + break label_42; + if (_d5 >= 10000) { + _hs[0] = (_d5 - 10000); + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 120) + 16) < 0 ? ((iL[2] + 120) + 16) : ((iL[2] + 120) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 120) + 8) < 0 ? ((iL[2] + 120) + 8) : ((iL[2] + 120) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 120, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_52 = new long[3]; + callArgs_52[2] = ((long) iL[1]); + callArgs_52[1] = ((long) (iL[2] + 120)); + callArgs_52[0] = ((long) iL[0]); + long[] callResult_52 = instance.getMachine().call(1268, callArgs_52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_52[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 144) + 16) < 0 ? ((iL[2] + 144) + 16) : ((iL[2] + 144) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 144) + 8) < 0 ? ((iL[2] + 144) + 8) : ((iL[2] + 144) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 144, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_53 = new long[3]; + callArgs_53[2] = ((long) iL[1]); + callArgs_53[1] = ((long) (iL[2] + 144)); + callArgs_53[0] = ((long) iL[0]); + long[] callResult_53 = instance.getMachine().call(1269, callArgs_53); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_53[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 168) + 16) < 0 ? ((iL[2] + 168) + 16) : ((iL[2] + 168) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 168) + 8) < 0 ? ((iL[2] + 168) + 8) : ((iL[2] + 168) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 168, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_54 = new long[3]; + callArgs_54[2] = ((long) iL[1]); + callArgs_54[1] = ((long) (iL[2] + 168)); + callArgs_54[0] = ((long) iL[0]); + long[] callResult_54 = instance.getMachine().call(1270, callArgs_54); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_54[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 192) + 16) < 0 ? ((iL[2] + 192) + 16) : ((iL[2] + 192) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 192) + 8) < 0 ? ((iL[2] + 192) + 8) : ((iL[2] + 192) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 192, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_55 = new long[3]; + callArgs_55[2] = ((long) iL[1]); + callArgs_55[1] = ((long) (iL[2] + 192)); + callArgs_55[0] = ((long) iL[0]); + long[] callResult_55 = instance.getMachine().call(1271, callArgs_55); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_55[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeI32((int) ((iL[2] + 256) + 16) < 0 ? ((iL[2] + 256) + 16) : ((iL[2] + 256) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 256) + 8) < 0 ? ((iL[2] + 256) + 8) : ((iL[2] + 256) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 256, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) ((iL[2] + 216) + 8) < 0 ? ((iL[2] + 216) + 8) : ((iL[2] + 216) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeLong((int) ((iL[2] + 216) + 16) < 0 ? ((iL[2] + 216) + 16) : ((iL[2] + 216) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 216) + 24) < 0 ? ((iL[2] + 216) + 24) : ((iL[2] + 216) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeI32((int) ((iL[2] + 216) + 32) < 0 ? ((iL[2] + 216) + 32) : ((iL[2] + 216) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 216, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_56 = new long[4]; + callArgs_56[3] = ((long) iL[1]); + callArgs_56[2] = ((long) (iL[2] + 216)); + callArgs_56[1] = ((long) (iL[2] + 256)); + callArgs_56[0] = ((long) iL[0]); + long[] callResult_56 = instance.getMachine().call(1272, callArgs_56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_56[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeI32((int) ((iL[2] + 320) + 16) < 0 ? ((iL[2] + 320) + 16) : ((iL[2] + 320) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 320) + 8) < 0 ? ((iL[2] + 320) + 8) : ((iL[2] + 320) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 320, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) ((iL[2] + 280) + 8) < 0 ? ((iL[2] + 280) + 8) : ((iL[2] + 280) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeLong((int) ((iL[2] + 280) + 16) < 0 ? ((iL[2] + 280) + 16) : ((iL[2] + 280) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 280) + 24) < 0 ? ((iL[2] + 280) + 24) : ((iL[2] + 280) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeI32((int) ((iL[2] + 280) + 32) < 0 ? ((iL[2] + 280) + 32) : ((iL[2] + 280) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 280, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_57 = new long[4]; + callArgs_57[3] = ((long) iL[1]); + callArgs_57[2] = ((long) (iL[2] + 280)); + callArgs_57[1] = ((long) (iL[2] + 320)); + callArgs_57[0] = ((long) iL[0]); + long[] callResult_57 = instance.getMachine().call(1273, callArgs_57); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_57[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + memory.writeI32((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (int) 0); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) 0L); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) 0L); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 1572, (int) 0); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 1556, (int) 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1540, (long) -1L); + iL[5] = 1; + long[] callArgs_58 = new long[3]; + callArgs_58[2] = ((long) 0); + callArgs_58[1] = ((long) (iL[2] + 1520)); + callArgs_58[0] = ((long) iL[0]); + long[] callResult_58 = instance.getMachine().call(1274, callArgs_58); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_58[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + long[] callArgs_59 = new long[1]; + callArgs_59[0] = ((long) 104); + long[] callResult_59 = instance.getMachine().call(1776, callArgs_59); + iL[0] = ((int) callResult_59[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 17); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 48964); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) (iL[2] + 1696) < 0 ? (iL[2] + 1696) : (iL[2] + 1696) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) (iL[2] + 1704) < 0 ? (iL[2] + 1704) : (iL[2] + 1704) + 0)); + long[] callArgs_60 = new long[3]; + callArgs_60[2] = ((long) 68); + callArgs_60[1] = ((long) (iL[2] + 1520)); + callArgs_60[0] = ((long) (iL[0] + 36)); + long[] callResult_60 = instance.getMachine().call(1890, callArgs_60); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + int ciTableIdx_61 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_61 = instance.table(0).requiredRef(ciTableIdx_61); + com.dylibso.chicory.runtime.Instance ciRefInstance_61 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_61), instance); + if (!ciRefInstance_61.type(ciRefInstance_61.functionType(ciFuncId_61)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_61 = new long[1]; + callArgs_61[0] = ((long) iL[3]); + ciRefInstance_61.getMachine().call(ciFuncId_61, callArgs_61); + { + _hs[0] = 10020; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + iL[5] = ((iL[2] + 1520) + 24); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_62 = new long[2]; + callArgs_62[1] = ((long) (iL[2] + 1520)); + callArgs_62[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_62); + long[] callArgs_63 = new long[1]; + callArgs_63[0] = ((long) 40); + long[] callResult_63 = instance.getMachine().call(1776, callArgs_63); + iL[0] = ((int) callResult_63[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 63); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 53768); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 36, (int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + int ciTableIdx_64 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_64 = instance.table(0).requiredRef(ciTableIdx_64); + com.dylibso.chicory.runtime.Instance ciRefInstance_64 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_64), instance); + if (!ciRefInstance_64.type(ciRefInstance_64.functionType(ciFuncId_64)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_64 = new long[1]; + callArgs_64[0] = ((long) iL[3]); + ciRefInstance_64.getMachine().call(ciFuncId_64, callArgs_64); + { + _hs[0] = 10020; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + iL[5] = ((iL[2] + 1520) + 24); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_65 = new long[2]; + callArgs_65[1] = ((long) (iL[2] + 1520)); + callArgs_65[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_65); + long[] callArgs_66 = new long[1]; + callArgs_66[0] = ((long) 40); + long[] callResult_66 = instance.getMachine().call(1776, callArgs_66); + iL[0] = ((int) callResult_66[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 7); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 53884); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 36, (int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + int ciTableIdx_67 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_67 = instance.table(0).requiredRef(ciTableIdx_67); + com.dylibso.chicory.runtime.Instance ciRefInstance_67 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_67), instance); + if (!ciRefInstance_67.type(ciRefInstance_67.functionType(ciFuncId_67)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_67 = new long[1]; + callArgs_67[0] = ((long) iL[3]); + ciRefInstance_67.getMachine().call(ciFuncId_67, callArgs_67); + { + _hs[0] = 10020; + break _hb; + } + } + long[] callArgs_68 = new long[1]; + callArgs_68[0] = ((long) 40); + long[] callResult_68 = instance.getMachine().call(1776, callArgs_68); + iL[0] = ((int) callResult_68[0]); + iL[6] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[5] = (iL[3] + (iL[6] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 16); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 54000); + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (byte) ((iL[6] ^ 1))); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 36, (int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 24)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 36, (byte) (0)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) (iL[2] + 1696) < 0 ? (iL[2] + 1696) : (iL[2] + 1696) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + int ciTableIdx_69 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_69 = instance.table(0).requiredRef(ciTableIdx_69); + com.dylibso.chicory.runtime.Instance ciRefInstance_69 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_69), instance); + if (!ciRefInstance_69.type(ciRefInstance_69.functionType(ciFuncId_69)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_69 = new long[1]; + callArgs_69[0] = ((long) iL[3]); + ciRefInstance_69.getMachine().call(ciFuncId_69, callArgs_69); + { + _hs[0] = 10020; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + iL[5] = ((iL[2] + 1520) + 24); + memory.writeLong((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_70 = new long[2]; + callArgs_70[1] = ((long) (iL[2] + 1520)); + callArgs_70[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_70); + long[] callArgs_71 = new long[1]; + callArgs_71[0] = ((long) 40); + long[] callResult_71 = instance.getMachine().call(1776, callArgs_71); + iL[0] = ((int) callResult_71[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 18); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 54116); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 36, (int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + int ciTableIdx_72 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_72 = instance.table(0).requiredRef(ciTableIdx_72); + com.dylibso.chicory.runtime.Instance ciRefInstance_72 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_72), instance); + if (!ciRefInstance_72.type(ciRefInstance_72.functionType(ciFuncId_72)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_72 = new long[1]; + callArgs_72[0] = ((long) iL[3]); + ciRefInstance_72.getMachine().call(ciFuncId_72, callArgs_72); + { + _hs[0] = 10020; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1183__h1(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_22: { + label_23: { + label_24: { + label_25: { + label_26: { + label_27: { + label_28: { + iL[9] = (int) (byte) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 1); + switch((iL[9] + -92)) { + case 0: + { + break label_24; + } + case 1: + { + { + _hs[0] = 1; + break _hb; + } + } + case 2: + { + { + _hs[0] = 1; + break _hb; + } + } + case 3: + { + { + _hs[0] = 1; + break _hb; + } + } + case 4: + { + { + _hs[0] = 1; + break _hb; + } + } + case 5: + { + { + _hs[0] = 1; + break _hb; + } + } + case 6: + { + { + _hs[0] = 1; + break _hb; + } + } + case 7: + { + { + _hs[0] = 1; + break _hb; + } + } + case 8: + { + { + _hs[0] = 1; + break _hb; + } + } + case 9: + { + { + _hs[0] = 1; + break _hb; + } + } + case 10: + { + { + _hs[0] = 1; + break _hb; + } + } + case 11: + { + { + _hs[0] = 1; + break _hb; + } + } + case 12: + { + { + _hs[0] = 1; + break _hb; + } + } + case 13: + { + { + _hs[0] = 1; + break _hb; + } + } + case 14: + { + { + _hs[0] = 1; + break _hb; + } + } + case 15: + { + { + _hs[0] = 1; + break _hb; + } + } + case 16: + { + { + _hs[0] = 1; + break _hb; + } + } + case 17: + { + { + _hs[0] = 1; + break _hb; + } + } + case 18: + { + break label_27; + } + case 19: + { + { + _hs[0] = 1; + break _hb; + } + } + case 20: + { + { + _hs[0] = 1; + break _hb; + } + } + case 21: + { + { + _hs[0] = 1; + break _hb; + } + } + case 22: + { + break label_26; + } + case 23: + { + { + _hs[0] = 1; + break _hb; + } + } + case 24: + { + break label_25; + } + case 25: + { + break _hb; + } + default: + { + break label_28; + } + } + } + switch((iL[9] + -34)) { + case 0: + { + break label_22; + } + case 1: + { + { + _hs[0] = 1; + break _hb; + } + } + case 2: + { + { + _hs[0] = 1; + break _hb; + } + } + case 3: + { + { + _hs[0] = 1; + break _hb; + } + } + case 4: + { + { + _hs[0] = 1; + break _hb; + } + } + case 5: + { + break label_23; + } + default: + { + { + _hs[0] = 1; + break _hb; + } + } + } + } + label_29: { + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[0]) != 0) { + break label_29; + } + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (byte) (10)); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[9] + 1)); + { + _hs[0] = 10001; + break _hb; + } + } + iL[10] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[13] = (iL[9] - iL[10]); + iL[5] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[5], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_30: { + label_31: { + iL[0] = (iL[0] - iL[10]); + iL[4] = (iL[0] << 1); + iL[5] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[4], iL[5]) != 0 ? iL[4] : iL[5]) : 2147483647); + if (iL[5] != 0) { + break label_31; + } + iL[4] = 0; + break label_30; + } + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) iL[5]); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + iL[4] = ((int) callResult_4[0]); + } + iL[0] = (iL[4] + iL[13]); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (10)); + iL[14] = (iL[4] + iL[5]); + iL[15] = (iL[0] + 1); + label_32: { + label_33: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + break label_33; + } + iL[4] = iL[0]; + break label_32; + } + iL[16] = ((iL[10] ^ -1) + iL[9]); + label_34: { + iL[5] = (iL[13] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_34; + } + label_35: while (true) { + iL[0] = (iL[0] + -1); + iL[9] = (iL[9] + -1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_35; + } + break; + } + } + label_36: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], 3) != 0) { + break label_36; + } + iL[0] = (iL[0] + -4); + label_37: while (true) { + memory.writeByte((int) (iL[0] + 3) < 0 ? (iL[0] + 3) : (iL[0] + 3) + 0, (byte) (((int) memory.read((int) (iL[9] + -1) < 0 ? (iL[9] + -1) : (iL[9] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 2) < 0 ? (iL[0] + 2) : (iL[0] + 2) + 0, (byte) (((int) memory.read((int) (iL[9] + -2) < 0 ? (iL[9] + -2) : (iL[9] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 1) < 0 ? (iL[0] + 1) : (iL[0] + 1) + 0, (byte) (((int) memory.read((int) (iL[9] + -3) < 0 ? (iL[9] + -3) : (iL[9] + -3) + 0) & 0xFF))); + iL[9] = (iL[9] + -4); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_37; + } + break; + } + } + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[14]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) iL[9]); + instance.getMachine().call(1777, callArgs_5); + { + _hs[0] = 10001; + break _hb; + } + } + label_38: { + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[0]) != 0) { + break label_38; + } + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (byte) (13)); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[9] + 1)); + { + _hs[0] = 10001; + break _hb; + } + } + iL[10] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[13] = (iL[9] - iL[10]); + iL[5] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[5], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_39: { + label_40: { + iL[0] = (iL[0] - iL[10]); + iL[4] = (iL[0] << 1); + iL[5] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[4], iL[5]) != 0 ? iL[4] : iL[5]) : 2147483647); + if (iL[5] != 0) { + break label_40; + } + iL[4] = 0; + break label_39; + } + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) iL[5]); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + iL[4] = ((int) callResult_6[0]); + } + iL[0] = (iL[4] + iL[13]); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (13)); + iL[14] = (iL[4] + iL[5]); + iL[15] = (iL[0] + 1); + label_41: { + label_42: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + break label_42; + } + iL[4] = iL[0]; + break label_41; + } + iL[16] = ((iL[10] ^ -1) + iL[9]); + label_43: { + iL[5] = (iL[13] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_43; + } + label_44: while (true) { + iL[0] = (iL[0] + -1); + iL[9] = (iL[9] + -1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_44; + } + break; + } + } + label_45: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], 3) != 0) { + break label_45; + } + iL[0] = (iL[0] + -4); + label_46: while (true) { + memory.writeByte((int) (iL[0] + 3) < 0 ? (iL[0] + 3) : (iL[0] + 3) + 0, (byte) (((int) memory.read((int) (iL[9] + -1) < 0 ? (iL[9] + -1) : (iL[9] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 2) < 0 ? (iL[0] + 2) : (iL[0] + 2) + 0, (byte) (((int) memory.read((int) (iL[9] + -2) < 0 ? (iL[9] + -2) : (iL[9] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 1) < 0 ? (iL[0] + 1) : (iL[0] + 1) + 0, (byte) (((int) memory.read((int) (iL[9] + -3) < 0 ? (iL[9] + -3) : (iL[9] + -3) + 0) & 0xFF))); + iL[9] = (iL[9] + -4); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_46; + } + break; + } + } + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[14]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) iL[9]); + instance.getMachine().call(1777, callArgs_7); + { + _hs[0] = 10001; + break _hb; + } + } + label_47: { + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[0]) != 0) { + break label_47; + } + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (byte) (9)); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[9] + 1)); + { + _hs[0] = 10001; + break _hb; + } + } + iL[10] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[13] = (iL[9] - iL[10]); + iL[5] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[5], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_48: { + label_49: { + iL[0] = (iL[0] - iL[10]); + iL[4] = (iL[0] << 1); + iL[5] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[4], iL[5]) != 0 ? iL[4] : iL[5]) : 2147483647); + if (iL[5] != 0) { + break label_49; + } + iL[4] = 0; + break label_48; + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) iL[5]); + long[] callResult_8 = instance.getMachine().call(1776, callArgs_8); + iL[4] = ((int) callResult_8[0]); + } + iL[0] = (iL[4] + iL[13]); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (9)); + iL[14] = (iL[4] + iL[5]); + iL[15] = (iL[0] + 1); + label_50: { + label_51: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + break label_51; + } + iL[4] = iL[0]; + break label_50; + } + iL[16] = ((iL[10] ^ -1) + iL[9]); + label_52: { + iL[5] = (iL[13] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_52; + } + label_53: while (true) { + iL[0] = (iL[0] + -1); + iL[9] = (iL[9] + -1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_53; + } + break; + } + } + label_54: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], 3) != 0) { + break label_54; + } + iL[0] = (iL[0] + -4); + label_55: while (true) { + memory.writeByte((int) (iL[0] + 3) < 0 ? (iL[0] + 3) : (iL[0] + 3) + 0, (byte) (((int) memory.read((int) (iL[9] + -1) < 0 ? (iL[9] + -1) : (iL[9] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 2) < 0 ? (iL[0] + 2) : (iL[0] + 2) + 0, (byte) (((int) memory.read((int) (iL[9] + -2) < 0 ? (iL[9] + -2) : (iL[9] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 1) < 0 ? (iL[0] + 1) : (iL[0] + 1) + 0, (byte) (((int) memory.read((int) (iL[9] + -3) < 0 ? (iL[9] + -3) : (iL[9] + -3) + 0) & 0xFF))); + iL[9] = (iL[9] + -4); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_55; + } + break; + } + } + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[14]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) iL[9]); + instance.getMachine().call(1777, callArgs_9); + { + _hs[0] = 10001; + break _hb; + } + } + label_56: { + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[0]) != 0) { + break label_56; + } + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (byte) (92)); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[9] + 1)); + { + _hs[0] = 10001; + break _hb; + } + } + iL[10] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[13] = (iL[9] - iL[10]); + iL[5] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[5], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_57: { + label_58: { + iL[0] = (iL[0] - iL[10]); + iL[4] = (iL[0] << 1); + iL[5] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[4], iL[5]) != 0 ? iL[4] : iL[5]) : 2147483647); + if (iL[5] != 0) { + break label_58; + } + iL[4] = 0; + break label_57; + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) iL[5]); + long[] callResult_10 = instance.getMachine().call(1776, callArgs_10); + iL[4] = ((int) callResult_10[0]); + } + iL[0] = (iL[4] + iL[13]); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (92)); + iL[14] = (iL[4] + iL[5]); + iL[15] = (iL[0] + 1); + label_59: { + label_60: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + break label_60; + } + iL[4] = iL[0]; + break label_59; + } + iL[16] = ((iL[10] ^ -1) + iL[9]); + label_61: { + iL[5] = (iL[13] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_61; + } + label_62: while (true) { + iL[0] = (iL[0] + -1); + iL[9] = (iL[9] + -1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_62; + } + break; + } + } + label_63: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], 3) != 0) { + break label_63; + } + iL[0] = (iL[0] + -4); + label_64: while (true) { + memory.writeByte((int) (iL[0] + 3) < 0 ? (iL[0] + 3) : (iL[0] + 3) + 0, (byte) (((int) memory.read((int) (iL[9] + -1) < 0 ? (iL[9] + -1) : (iL[9] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 2) < 0 ? (iL[0] + 2) : (iL[0] + 2) + 0, (byte) (((int) memory.read((int) (iL[9] + -2) < 0 ? (iL[9] + -2) : (iL[9] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 1) < 0 ? (iL[0] + 1) : (iL[0] + 1) + 0, (byte) (((int) memory.read((int) (iL[9] + -3) < 0 ? (iL[9] + -3) : (iL[9] + -3) + 0) & 0xFF))); + iL[9] = (iL[9] + -4); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_64; + } + break; + } + } + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[14]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) iL[9]); + instance.getMachine().call(1777, callArgs_11); + { + _hs[0] = 10001; + break _hb; + } + } + label_65: { + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[0]) != 0) { + break label_65; + } + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (byte) (39)); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[9] + 1)); + { + _hs[0] = 10001; + break _hb; + } + } + iL[10] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[13] = (iL[9] - iL[10]); + iL[5] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[5], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_66: { + label_67: { + iL[0] = (iL[0] - iL[10]); + iL[4] = (iL[0] << 1); + iL[5] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[4], iL[5]) != 0 ? iL[4] : iL[5]) : 2147483647); + if (iL[5] != 0) { + break label_67; + } + iL[4] = 0; + break label_66; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) iL[5]); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + iL[4] = ((int) callResult_12[0]); + } + iL[0] = (iL[4] + iL[13]); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (39)); + iL[14] = (iL[4] + iL[5]); + iL[15] = (iL[0] + 1); + label_68: { + label_69: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + break label_69; + } + iL[4] = iL[0]; + break label_68; + } + iL[16] = ((iL[10] ^ -1) + iL[9]); + label_70: { + iL[5] = (iL[13] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_70; + } + label_71: while (true) { + iL[0] = (iL[0] + -1); + iL[9] = (iL[9] + -1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_71; + } + break; + } + } + label_72: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], 3) != 0) { + break label_72; + } + iL[0] = (iL[0] + -4); + label_73: while (true) { + memory.writeByte((int) (iL[0] + 3) < 0 ? (iL[0] + 3) : (iL[0] + 3) + 0, (byte) (((int) memory.read((int) (iL[9] + -1) < 0 ? (iL[9] + -1) : (iL[9] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 2) < 0 ? (iL[0] + 2) : (iL[0] + 2) + 0, (byte) (((int) memory.read((int) (iL[9] + -2) < 0 ? (iL[9] + -2) : (iL[9] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 1) < 0 ? (iL[0] + 1) : (iL[0] + 1) + 0, (byte) (((int) memory.read((int) (iL[9] + -3) < 0 ? (iL[9] + -3) : (iL[9] + -3) + 0) & 0xFF))); + iL[9] = (iL[9] + -4); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_73; + } + break; + } + } + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[14]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) iL[9]); + instance.getMachine().call(1777, callArgs_13); + { + _hs[0] = 10001; + break _hb; + } + } + label_74: { + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[9], iL[0]) != 0) { + break label_74; + } + memory.writeByte((int) iL[9] < 0 ? iL[9] : iL[9] + 0, (byte) (34)); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[9] + 1)); + { + _hs[0] = 10001; + break _hb; + } + } + iL[10] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[13] = (iL[9] - iL[10]); + iL[5] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[5], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_75: { + label_76: { + iL[0] = (iL[0] - iL[10]); + iL[4] = (iL[0] << 1); + iL[5] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[4], iL[5]) != 0 ? iL[4] : iL[5]) : 2147483647); + if (iL[5] != 0) { + break label_76; + } + iL[4] = 0; + break label_75; + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) iL[5]); + long[] callResult_14 = instance.getMachine().call(1776, callArgs_14); + iL[4] = ((int) callResult_14[0]); + } + iL[0] = (iL[4] + iL[13]); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (34)); + iL[14] = (iL[4] + iL[5]); + iL[15] = (iL[0] + 1); + label_77: { + label_78: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + break label_78; + } + iL[4] = iL[0]; + break label_77; + } + iL[16] = ((iL[10] ^ -1) + iL[9]); + label_79: { + iL[5] = (iL[13] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_79; + } + label_80: while (true) { + iL[0] = (iL[0] + -1); + iL[9] = (iL[9] + -1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[5] = (iL[5] + -1); + if (iL[5] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_80; + } + break; + } + } + label_81: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], 3) != 0) { + break label_81; + } + iL[0] = (iL[0] + -4); + label_82: while (true) { + memory.writeByte((int) (iL[0] + 3) < 0 ? (iL[0] + 3) : (iL[0] + 3) + 0, (byte) (((int) memory.read((int) (iL[9] + -1) < 0 ? (iL[9] + -1) : (iL[9] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 2) < 0 ? (iL[0] + 2) : (iL[0] + 2) + 0, (byte) (((int) memory.read((int) (iL[9] + -2) < 0 ? (iL[9] + -2) : (iL[9] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 1) < 0 ? (iL[0] + 1) : (iL[0] + 1) + 0, (byte) (((int) memory.read((int) (iL[9] + -3) < 0 ? (iL[9] + -3) : (iL[9] + -3) + 0) & 0xFF))); + iL[9] = (iL[9] + -4); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[9] < 0 ? iL[9] : iL[9] + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[10], iL[9]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_82; + } + break; + } + } + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[14]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[9]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) iL[9]); + instance.getMachine().call(1777, callArgs_15); + { + _hs[0] = 10001; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1257__h1(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_9: { + label_10: { + label_11: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) iL[0]); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + iL[4] = ((int) callResult_1[0]); + switch((iL[4] + -90)) { + case 0: + { + break label_9; + } + case 1: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 2: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 3: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 4: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 5: + { + break label_10; + } + case 6: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 7: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 8: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 9: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 10: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 11: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 12: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 13: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 14: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 15: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 16: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 17: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 18: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 19: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 20: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 21: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 22: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 23: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 24: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 25: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 26: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 27: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 28: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 29: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 30: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 31: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 32: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 33: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 34: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 35: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 36: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 37: + { + break _hb; + } + case 38: + { + { + _hs[0] = 10000; + break _hb; + } + } + default: + { + break label_11; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(68, iL[4]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 184); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + iL[4] = ((int) callResult_2[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 4, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 32, (int) 8); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 36, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) 57720); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 88)); + memory.writeLong((int) (iL[4] + 20) < 0 ? (iL[4] + 20) : (iL[4] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 88) + 8) < 0 ? ((iL[2] + 88) + 8) : ((iL[2] + 88) + 8) + 0)); + memory.writeI32((int) (iL[4] + 28) < 0 ? (iL[4] + 28) : (iL[4] + 28) + 0, (int) memory.readInt((int) (iL[2] + 104) < 0 ? (iL[2] + 104) : (iL[2] + 104) + 0)); + memory.writeLong((int) (iL[4] + 41) < 0 ? (iL[4] + 41) : (iL[4] + 41) + 0, (long) 0L); + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) (iL[4] + 52)); + long[] callResult_3 = instance.getMachine().call(154, callArgs_3); + memory.writeLong((int) (iL[4] + 120) < 0 ? (iL[4] + 120) : (iL[4] + 120) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 112) < 0 ? (iL[4] + 112) : (iL[4] + 112) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 104) < 0 ? (iL[4] + 104) : (iL[4] + 104) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 96) < 0 ? (iL[4] + 96) : (iL[4] + 96) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 88) < 0 ? (iL[4] + 88) : (iL[4] + 88) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 132) < 0 ? (iL[4] + 132) : (iL[4] + 132) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 128) < 0 ? (iL[4] + 128) : (iL[4] + 128) + 0, (int) 1065353216); + memory.writeLong((int) (iL[4] + 140) < 0 ? (iL[4] + 140) : (iL[4] + 140) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 152) < 0 ? (iL[4] + 152) : (iL[4] + 152) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 148) < 0 ? (iL[4] + 148) : (iL[4] + 148) + 0, (int) 1065353216); + memory.writeLong((int) (iL[4] + 160) < 0 ? (iL[4] + 160) : (iL[4] + 160) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 168) < 0 ? (iL[4] + 168) : (iL[4] + 168) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 176) < 0 ? (iL[4] + 176) : (iL[4] + 176) + 0, (long) 0L); + label_12: { + iL[3] = (iL[4] + 36); + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) iL[3]); + callArgs_4[0] = ((long) iL[0]); + long[] callResult_4 = instance.getMachine().call(1178, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_4[0])) != 0) { + break label_12; + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) iL[3]); + callArgs_5[0] = ((long) iL[0]); + long[] callResult_5 = instance.getMachine().call(1179, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_5[0])) != 0) { + break label_12; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) 87); + callArgs_6[0] = ((long) iL[0]); + long[] callResult_6 = instance.getMachine().call(1160, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_6[0])) != 0) { + break label_12; + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) iL[3]); + callArgs_7[0] = ((long) iL[0]); + long[] callResult_7 = instance.getMachine().call(1297, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_7[0])) != 0) { + break label_12; + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + iL[5] = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + int ciTableIdx_8 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[1]; + callArgs_8[0] = ((long) iL[0]); + ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + { + _hs[0] = 10001; + break _hb; + } + } + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 4)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) iL[4]); + ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + { + _hs[0] = 10001; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) 184); + long[] callResult_10 = instance.getMachine().call(1776, callArgs_10); + iL[4] = ((int) callResult_10[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 4, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 32, (int) 27); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 36, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) 57840); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 88)); + memory.writeLong((int) (iL[4] + 20) < 0 ? (iL[4] + 20) : (iL[4] + 20) + 0, (long) memory.readLong((int) (iL[2] + 96) < 0 ? (iL[2] + 96) : (iL[2] + 96) + 0)); + memory.writeI32((int) (iL[4] + 28) < 0 ? (iL[4] + 28) : (iL[4] + 28) + 0, (int) memory.readInt((int) (iL[2] + 104) < 0 ? (iL[2] + 104) : (iL[2] + 104) + 0)); + memory.writeLong((int) (iL[4] + 41) < 0 ? (iL[4] + 41) : (iL[4] + 41) + 0, (long) 0L); + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) (iL[4] + 52)); + long[] callResult_11 = instance.getMachine().call(154, callArgs_11); + memory.writeLong((int) (iL[4] + 120) < 0 ? (iL[4] + 120) : (iL[4] + 120) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 112) < 0 ? (iL[4] + 112) : (iL[4] + 112) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 104) < 0 ? (iL[4] + 104) : (iL[4] + 104) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 96) < 0 ? (iL[4] + 96) : (iL[4] + 96) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 88) < 0 ? (iL[4] + 88) : (iL[4] + 88) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 132) < 0 ? (iL[4] + 132) : (iL[4] + 132) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 128) < 0 ? (iL[4] + 128) : (iL[4] + 128) + 0, (int) 1065353216); + memory.writeLong((int) (iL[4] + 140) < 0 ? (iL[4] + 140) : (iL[4] + 140) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 152) < 0 ? (iL[4] + 152) : (iL[4] + 152) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 148) < 0 ? (iL[4] + 148) : (iL[4] + 148) + 0, (int) 1065353216); + memory.writeLong((int) (iL[4] + 160) < 0 ? (iL[4] + 160) : (iL[4] + 160) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 168) < 0 ? (iL[4] + 168) : (iL[4] + 168) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 176) < 0 ? (iL[4] + 176) : (iL[4] + 176) + 0, (long) 0L); + label_13: { + iL[3] = (iL[4] + 36); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) iL[3]); + callArgs_12[0] = ((long) iL[0]); + long[] callResult_12 = instance.getMachine().call(1178, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) != 0) { + break label_13; + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) iL[3]); + callArgs_13[0] = ((long) iL[0]); + long[] callResult_13 = instance.getMachine().call(1179, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_13[0])) != 0) { + break label_13; + } + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) 87); + callArgs_14[0] = ((long) iL[0]); + long[] callResult_14 = instance.getMachine().call(1160, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_14[0])) != 0) { + break label_13; + } + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) iL[3]); + callArgs_15[0] = ((long) iL[0]); + long[] callResult_15 = instance.getMachine().call(1297, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_15[0])) != 0) { + break label_13; + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + iL[5] = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + int ciTableIdx_16 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_16 = instance.table(0).requiredRef(ciTableIdx_16); + com.dylibso.chicory.runtime.Instance ciRefInstance_16 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_16), instance); + if (!ciRefInstance_16.type(ciRefInstance_16.functionType(ciFuncId_16)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) iL[0]); + ciRefInstance_16.getMachine().call(ciFuncId_16, callArgs_16); + { + _hs[0] = 10001; + break _hb; + } + } + int ciTableIdx_17 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 4)); + int ciFuncId_17 = instance.table(0).requiredRef(ciTableIdx_17); + com.dylibso.chicory.runtime.Instance ciRefInstance_17 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_17), instance); + if (!ciRefInstance_17.type(ciRefInstance_17.functionType(ciFuncId_17)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) iL[4]); + ciRefInstance_17.getMachine().call(ciFuncId_17, callArgs_17); + { + _hs[0] = 10001; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[5] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeByte((int) (iL[5] + 36) < 0 ? (iL[5] + 36) : (iL[5] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) 216); + long[] callResult_18 = instance.getMachine().call(1776, callArgs_18); + iL[4] = ((int) callResult_18[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 4, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 32, (int) 22); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 36, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) 57960); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 88)); + memory.writeLong((int) (iL[4] + 20) < 0 ? (iL[4] + 20) : (iL[4] + 20) + 0, (long) memory.readLong((int) (iL[2] + 96) < 0 ? (iL[2] + 96) : (iL[2] + 96) + 0)); + memory.writeI32((int) (iL[4] + 28) < 0 ? (iL[4] + 28) : (iL[4] + 28) + 0, (int) memory.readInt((int) (iL[2] + 104) < 0 ? (iL[2] + 104) : (iL[2] + 104) + 0)); + memory.writeLong((int) (iL[4] + 41) < 0 ? (iL[4] + 41) : (iL[4] + 41) + 0, (long) 0L); + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) (iL[4] + 52)); + long[] callResult_19 = instance.getMachine().call(154, callArgs_19); + memory.writeLong((int) (iL[4] + 120) < 0 ? (iL[4] + 120) : (iL[4] + 120) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 112) < 0 ? (iL[4] + 112) : (iL[4] + 112) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 104) < 0 ? (iL[4] + 104) : (iL[4] + 104) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 96) < 0 ? (iL[4] + 96) : (iL[4] + 96) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 88) < 0 ? (iL[4] + 88) : (iL[4] + 88) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 132) < 0 ? (iL[4] + 132) : (iL[4] + 132) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 128) < 0 ? (iL[4] + 128) : (iL[4] + 128) + 0, (int) 1065353216); + memory.writeLong((int) (iL[4] + 140) < 0 ? (iL[4] + 140) : (iL[4] + 140) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 152) < 0 ? (iL[4] + 152) : (iL[4] + 152) + 0, (long) 0L); + memory.writeI32((int) (iL[4] + 148) < 0 ? (iL[4] + 148) : (iL[4] + 148) + 0, (int) 1065353216); + memory.writeLong((int) (iL[4] + 160) < 0 ? (iL[4] + 160) : (iL[4] + 160) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 168) < 0 ? (iL[4] + 168) : (iL[4] + 168) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 176) < 0 ? (iL[4] + 176) : (iL[4] + 176) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 184) < 0 ? (iL[4] + 184) : (iL[4] + 184) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 192) < 0 ? (iL[4] + 192) : (iL[4] + 192) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 200) < 0 ? (iL[4] + 200) : (iL[4] + 200) + 0, (long) 0L); + memory.writeLong((int) (iL[4] + 208) < 0 ? (iL[4] + 208) : (iL[4] + 208) + 0, (long) 0L); + label_14: { + iL[6] = (iL[4] + 36); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) iL[6]); + callArgs_20[0] = ((long) iL[0]); + long[] callResult_20 = instance.getMachine().call(1178, callArgs_20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_20[0])) != 0) { + break label_14; + } + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) iL[6]); + callArgs_21[0] = ((long) iL[0]); + long[] callResult_21 = instance.getMachine().call(1179, callArgs_21); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_21[0])) != 0) { + break label_14; + } + label_15: { + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) 0); + callArgs_22[0] = ((long) iL[0]); + long[] callResult_22 = instance.getMachine().call(1154, callArgs_22); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(86, ((int) callResult_22[0])) != 0) { + break label_15; + } + iL[7] = ((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 96) & 0xFF); + iL[3] = (iL[3] + (iL[7] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[7] ^ 1))); + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) iL[6]); + callArgs_23[0] = ((long) iL[0]); + long[] callResult_23 = instance.getMachine().call(1297, callArgs_23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_23[0])) != 0) { + break label_14; + } + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) (iL[4] + 184)); + callArgs_24[0] = ((long) iL[0]); + long[] callResult_24 = instance.getMachine().call(1173, callArgs_24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_24[0])) != 0) { + break label_14; + } + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) iL[0]); + callArgs_25[0] = ((long) (iL[2] + 144)); + instance.getMachine().call(1153, callArgs_25); + memory.writeI32((int) (iL[4] + 212) < 0 ? (iL[4] + 212) : (iL[4] + 212) + 0, (int) memory.readInt((int) (iL[2] + 160) < 0 ? (iL[2] + 160) : (iL[2] + 160) + 0)); + memory.writeLong((int) (iL[4] + 204) < 0 ? (iL[4] + 204) : (iL[4] + 204) + 0, (long) memory.readLong((int) (iL[2] + 152) < 0 ? (iL[2] + 152) : (iL[2] + 152) + 0)); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 196, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 144)); + } + long[] callArgs_26 = new long[2]; + callArgs_26[1] = ((long) 87); + callArgs_26[0] = ((long) iL[0]); + long[] callResult_26 = instance.getMachine().call(1160, callArgs_26); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_26[0])) != 0) { + break label_14; + } + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) iL[6]); + callArgs_27[0] = ((long) iL[0]); + long[] callResult_27 = instance.getMachine().call(1297, callArgs_27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_27[0])) != 0) { + break label_14; + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + iL[5] = 0; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + int ciTableIdx_28 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_28 = instance.table(0).requiredRef(ciTableIdx_28); + com.dylibso.chicory.runtime.Instance ciRefInstance_28 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_28), instance); + if (!ciRefInstance_28.type(ciRefInstance_28.functionType(ciFuncId_28)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) iL[0]); + ciRefInstance_28.getMachine().call(ciFuncId_28, callArgs_28); + { + _hs[0] = 10001; + break _hb; + } + } + int ciTableIdx_29 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 4)); + int ciFuncId_29 = instance.table(0).requiredRef(ciTableIdx_29); + com.dylibso.chicory.runtime.Instance ciRefInstance_29 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_29), instance); + if (!ciRefInstance_29.type(ciRefInstance_29.functionType(ciFuncId_29)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) iL[4]); + ciRefInstance_29.getMachine().call(ciFuncId_29, callArgs_29); + { + _hs[0] = 10001; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1871__h2(int[] iL, long[] lL, double[] dL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_59: { + label_60: { + label_61: { + label_62: { + label_63: { + label_64: { + label_65: { + label_66: { + int _d4 = func_1871__h4(iL, lL, dL, memory, instance); + if (_d4 == 1) + break label_61; + if (_d4 == 2) + break label_62; + if (_d4 == 3) + break label_65; + if (_d4 == 4) + break label_64; + if (_d4 >= 10000) { + _hs[0] = (_d4 - 10000); + break _hb; + } + } + memory.writeByte((int) iL[6] < 0 ? iL[6] : iL[6] + 55, (byte) (int) (memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 56))); + iL[29] = 0; + iL[24] = 2575; + iL[26] = 1; + iL[21] = iL[10]; + iL[20] = iL[17]; + { + _hs[0] = 10004; + break _hb; + } + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) memory.readInt((int) 658184 < 0 ? 658184 : 658184 + 0)); + long[] callResult_11 = instance.getMachine().call(1823, callArgs_11); + iL[21] = ((int) callResult_11[0]); + break label_63; + } + iL[20] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56); + iL[21] = (iL[20] != 0 ? iL[20] : 30266); + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[25], 2147483647) != 0 ? iL[25] : 2147483647)); + callArgs_12[0] = ((long) iL[21]); + long[] callResult_12 = instance.getMachine().call(1899, callArgs_12); + iL[26] = ((int) callResult_12[0]); + iL[20] = (iL[21] + iL[26]); + iL[29] = 0; + iL[24] = 2575; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[25], -1) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 0) & 0xFF)) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + { + _hs[0] = 10001; + break _hb; + } + } + iL[21] = memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56); + if (iL[25] != 0) { + break label_60; + } + iL[20] = 0; + break label_59; + } + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 12, (int) 0); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 8, (int) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 56)); + memory.writeI32((int) iL[6] < 0 ? iL[6] : iL[6] + 56, (int) (iL[6] + 8)); + iL[21] = (iL[6] + 8); + iL[25] = -1; + } + iL[20] = 0; + iL[22] = iL[21]; + label_94: { + label_95: while (true) { + iL[23] = memory.readInt((int) iL[22] < 0 ? iL[22] : iL[22] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[23]) != 0) { + break label_94; + } + label_96: { + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) iL[23]); + callArgs_13[0] = ((long) (iL[6] + 4)); + long[] callResult_13 = instance.getMachine().call(1868, callArgs_13); + iL[23] = ((int) callResult_13[0]); + iL[26] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[23], 0); + if (iL[26] != 0) { + break label_96; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[23], (iL[25] - iL[20])) != 0) { + break label_96; + } + iL[22] = (iL[22] + 4); + iL[20] = (iL[23] + iL[20]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[25], iL[20]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_95; + } + break label_94; + } + break; + } + if (iL[26] != 0) { + { + _hs[0] = 10005; + break _hb; + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[20], 0) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + } + label_97: { + iL[26] = (iL[31] & 73728); + if (iL[26] != 0) { + break label_97; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[27], iL[20]) != 0) { + break label_97; + } + iL[22] = (iL[27] - iL[20]); + iL[23] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[22], 256); + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) (iL[23] != 0 ? iL[22] : 256)); + callArgs_14[1] = ((long) 32); + callArgs_14[0] = ((long) (iL[6] + 112)); + long[] callResult_14 = instance.getMachine().call(1892, callArgs_14); + label_98: { + if (iL[23] != 0) { + break label_98; + } + label_99: while (true) { + label_100: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_100; + } + long[] callArgs_15 = new long[3]; + callArgs_15[2] = ((long) iL[0]); + callArgs_15[1] = ((long) 256); + callArgs_15[0] = ((long) (iL[6] + 112)); + long[] callResult_15 = instance.getMachine().call(1855, callArgs_15); + } + iL[22] = (iL[22] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[22], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_99; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_97; + } + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) iL[0]); + callArgs_16[1] = ((long) iL[22]); + callArgs_16[0] = ((long) (iL[6] + 112)); + long[] callResult_16 = instance.getMachine().call(1855, callArgs_16); + } + label_101: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[20]) != 0) { + break label_101; + } + iL[22] = 0; + label_102: while (true) { + iL[23] = memory.readInt((int) iL[21] < 0 ? iL[21] : iL[21] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[23]) != 0) { + break label_101; + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) iL[23]); + callArgs_17[0] = ((long) (iL[6] + 4)); + long[] callResult_17 = instance.getMachine().call(1868, callArgs_17); + iL[23] = ((int) callResult_17[0]); + iL[22] = (iL[23] + iL[22]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[22], iL[20]) != 0) { + break label_101; + } + label_103: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_103; + } + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) iL[0]); + callArgs_18[1] = ((long) iL[23]); + callArgs_18[0] = ((long) (iL[6] + 4)); + long[] callResult_18 = instance.getMachine().call(1855, callArgs_18); + } + iL[21] = (iL[21] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[22], iL[20]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_102; + } + break; + } + } + label_104: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(8192, iL[26]) != 0) { + break label_104; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[27], iL[20]) != 0) { + break label_104; + } + iL[22] = (iL[27] - iL[20]); + iL[23] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[22], 256); + long[] callArgs_19 = new long[3]; + callArgs_19[2] = ((long) (iL[23] != 0 ? iL[22] : 256)); + callArgs_19[1] = ((long) 32); + callArgs_19[0] = ((long) (iL[6] + 112)); + long[] callResult_19 = instance.getMachine().call(1892, callArgs_19); + label_105: { + if (iL[23] != 0) { + break label_105; + } + label_106: while (true) { + label_107: { + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_107; + } + long[] callArgs_20 = new long[3]; + callArgs_20[2] = ((long) iL[0]); + callArgs_20[1] = ((long) 256); + callArgs_20[0] = ((long) (iL[6] + 112)); + long[] callResult_20 = instance.getMachine().call(1855, callArgs_20); + } + iL[22] = (iL[22] + -256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[22], 255) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_106; + } + break; + } + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_104; + } + long[] callArgs_21 = new long[3]; + callArgs_21[2] = ((long) iL[0]); + callArgs_21[1] = ((long) iL[22]); + callArgs_21[0] = ((long) (iL[6] + 112)); + long[] callResult_21 = instance.getMachine().call(1855, callArgs_21); + } + iL[20] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[27], iL[20]) != 0 ? iL[27] : iL[20]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 10002; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_41__h2(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 20) & 0xFF)) != 0) { + break _hb; + } + long[] callArgs_314 = new long[2]; + callArgs_314[1] = ((long) 14424); + callArgs_314[0] = ((long) iL[0]); + instance.getMachine().call(52, callArgs_314); + long[] callArgs_315 = new long[3]; + callArgs_315[2] = ((long) 12768); + callArgs_315[1] = ((long) 2); + callArgs_315[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_315); + label_294: { + iL[24] = (iL[0] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) (iL[0] + 12) < 0 ? (iL[0] + 12) : (iL[0] + 12) + 0), memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0)) != 0) { + break label_294; + } + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (8)); + long[] callArgs_316 = new long[5]; + callArgs_316[4] = ((long) 0); + callArgs_316[3] = ((long) 17319); + callArgs_316[2] = ((long) 1); + callArgs_316[1] = ((long) (iL[23] + 560)); + callArgs_316[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_316); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 1); + iL[38] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4); + long[] callArgs_317 = new long[5]; + callArgs_317[4] = ((long) 0); + callArgs_317[3] = ((long) 30166); + callArgs_317[2] = ((long) (iL[38] != 0 ? 1 : 5)); + callArgs_317[1] = ((long) (iL[23] + 560)); + callArgs_317[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_317); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 108, (int) iL[36]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 116, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 4)); + long[] callArgs_318 = new long[3]; + callArgs_318[2] = ((long) 8138); + callArgs_318[1] = ((long) ((memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0) - memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12)) >> 5)); + callArgs_318[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_318); + label_295: { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12); + iL[36] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[37]) != 0) { + break label_295; + } + iL[37] = (iL[37] + 24); + label_296: while (true) { + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[24] = iL[37]; + iL[37] = (iL[24] + -24); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0))); + long[] callArgs_319 = new long[5]; + callArgs_319[4] = ((long) 0); + callArgs_319[3] = ((long) 15924); + callArgs_319[2] = ((long) 1); + callArgs_319[1] = ((long) (iL[23] + 560)); + callArgs_319[0] = ((long) iL[38]); + instance.getMachine().call(224, callArgs_319); + iL[38] = (iL[24] + -12); + long[] callArgs_320 = new long[3]; + callArgs_320[2] = ((long) 8296); + callArgs_320[1] = ((long) ((int) memory.read((int) iL[38] < 0 ? iL[38] : iL[38] + 0) & 0xFF)); + callArgs_320[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_320); + label_297: { + label_298: { + label_299: { + label_300: { + label_301: { + label_302: { + label_303: { + switch(memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0)) { + case 0: + { + break label_303; + } + case 1: + { + break label_302; + } + case 2: + { + break label_301; + } + case 3: + { + break label_300; + } + case 4: + { + break label_299; + } + case 5: + { + break label_298; + } + default: + { + break label_297; + } + } + } + long[] callArgs_321 = new long[3]; + callArgs_321[2] = ((long) 1564); + callArgs_321[1] = ((long) memory.readInt((int) (iL[24] + -8) < 0 ? (iL[24] + -8) : (iL[24] + -8) + 0)); + callArgs_321[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_321); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(16, (((int) memory.read((int) iL[38] < 0 ? iL[38] : iL[38] + 0) & 0xFF) & 80)) != 0) { + break label_297; + } + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + lL[0] = memory.readLong((int) (iL[24] + -20) < 0 ? (iL[24] + -20) : (iL[24] + -20) + 0); + iL[38] = (int) (lL[0] >>> 32L); + long[] callArgs_322 = new long[3]; + callArgs_322[2] = ((long) 14225); + callArgs_322[1] = ((long) iL[38]); + callArgs_322[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_322); + long[] callArgs_323 = new long[5]; + callArgs_323[4] = ((long) 1); + callArgs_323[3] = ((long) 16834); + callArgs_323[2] = ((long) iL[38]); + callArgs_323[1] = ((long) (int) lL[0]); + callArgs_323[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_323); + break label_297; + } + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + lL[0] = memory.readLong((int) (iL[24] + -20) < 0 ? (iL[24] + -20) : (iL[24] + -20) + 0); + iL[30] = (int) (lL[0] >>> 32L); + long[] callArgs_324 = new long[3]; + callArgs_324[2] = ((long) 14225); + callArgs_324[1] = ((long) iL[30]); + callArgs_324[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_324); + long[] callArgs_325 = new long[5]; + callArgs_325[4] = ((long) 1); + callArgs_325[3] = ((long) 16979); + callArgs_325[2] = ((long) iL[30]); + callArgs_325[1] = ((long) (int) lL[0]); + callArgs_325[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_325); + if ((((int) memory.read((int) iL[38] < 0 ? iL[38] : iL[38] + 0) & 0xFF) & 16) != 0) { + break label_297; + } + long[] callArgs_326 = new long[3]; + callArgs_326[2] = ((long) 2226); + callArgs_326[1] = ((long) memory.readInt((int) (iL[24] + -8) < 0 ? (iL[24] + -8) : (iL[24] + -8) + 0)); + callArgs_326[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_326); + long[] callArgs_327 = new long[3]; + callArgs_327[2] = ((long) 7290); + callArgs_327[1] = ((long) memory.readInt((int) (iL[24] + -4) < 0 ? (iL[24] + -4) : (iL[24] + -4) + 0)); + callArgs_327[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_327); + long[] callArgs_328 = new long[3]; + callArgs_328[2] = ((long) 15187); + callArgs_328[1] = ((long) memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0)); + callArgs_328[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_328); + break label_297; + } + long[] callArgs_329 = new long[3]; + callArgs_329[2] = ((long) 1762); + callArgs_329[1] = ((long) memory.readInt((int) (iL[24] + -8) < 0 ? (iL[24] + -8) : (iL[24] + -8) + 0)); + callArgs_329[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_329); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(16, (((int) memory.read((int) iL[38] < 0 ? iL[38] : iL[38] + 0) & 0xFF) & 80)) != 0) { + break label_297; + } + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + lL[0] = memory.readLong((int) (iL[24] + -20) < 0 ? (iL[24] + -20) : (iL[24] + -20) + 0); + iL[38] = (int) (lL[0] >>> 32L); + long[] callArgs_330 = new long[3]; + callArgs_330[2] = ((long) 14225); + callArgs_330[1] = ((long) iL[38]); + callArgs_330[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_330); + long[] callArgs_331 = new long[5]; + callArgs_331[4] = ((long) 1); + callArgs_331[3] = ((long) 16897); + callArgs_331[2] = ((long) iL[38]); + callArgs_331[1] = ((long) (int) lL[0]); + callArgs_331[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_331); + break label_297; + } + long[] callArgs_332 = new long[3]; + callArgs_332[2] = ((long) 1585); + callArgs_332[1] = ((long) memory.readInt((int) (iL[24] + -8) < 0 ? (iL[24] + -8) : (iL[24] + -8) + 0)); + callArgs_332[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_332); + break label_297; + } + long[] callArgs_333 = new long[3]; + callArgs_333[2] = ((long) 1782); + callArgs_333[1] = ((long) memory.readInt((int) (iL[24] + -8) < 0 ? (iL[24] + -8) : (iL[24] + -8) + 0)); + callArgs_333[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_333); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(16, (((int) memory.read((int) iL[38] < 0 ? iL[38] : iL[38] + 0) & 0xFF) & 80)) != 0) { + break label_297; + } + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + lL[0] = memory.readLong((int) (iL[24] + -20) < 0 ? (iL[24] + -20) : (iL[24] + -20) + 0); + iL[38] = (int) (lL[0] >>> 32L); + long[] callArgs_334 = new long[3]; + callArgs_334[2] = ((long) 14225); + callArgs_334[1] = ((long) iL[38]); + callArgs_334[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_334); + long[] callArgs_335 = new long[5]; + callArgs_335[4] = ((long) 1); + callArgs_335[3] = ((long) 16909); + callArgs_335[2] = ((long) iL[38]); + callArgs_335[1] = ((long) (int) lL[0]); + callArgs_335[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_335); + break label_297; + } + long[] callArgs_336 = new long[3]; + callArgs_336[2] = ((long) 2118); + callArgs_336[1] = ((long) memory.readInt((int) (iL[24] + -8) < 0 ? (iL[24] + -8) : (iL[24] + -8) + 0)); + callArgs_336[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_336); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(16, (((int) memory.read((int) iL[38] < 0 ? iL[38] : iL[38] + 0) & 0xFF) & 80)) != 0) { + break label_297; + } + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + lL[0] = memory.readLong((int) (iL[24] + -20) < 0 ? (iL[24] + -20) : (iL[24] + -20) + 0); + iL[38] = (int) (lL[0] >>> 32L); + long[] callArgs_337 = new long[3]; + callArgs_337[2] = ((long) 14225); + callArgs_337[1] = ((long) iL[38]); + callArgs_337[0] = ((long) iL[37]); + instance.getMachine().call(169, callArgs_337); + long[] callArgs_338 = new long[5]; + callArgs_338[4] = ((long) 1); + callArgs_338[3] = ((long) 16950); + callArgs_338[2] = ((long) iL[38]); + callArgs_338[1] = ((long) (int) lL[0]); + callArgs_338[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_338); + } + iL[37] = (iL[24] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], (iL[24] + 8)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_296; + } + break; + } + } + long[] callArgs_339 = new long[4]; + callArgs_339[3] = ((long) 14990); + callArgs_339[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 112)); + callArgs_339[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 108)); + callArgs_339[0] = ((long) iL[0]); + long[] callResult_339 = instance.getMachine().call(48, callArgs_339); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 112, (int) 0); + } + long[] callArgs_340 = new long[4]; + callArgs_340[3] = ((long) 15012); + callArgs_340[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_340[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_340[0] = ((long) iL[0]); + long[] callResult_340 = instance.getMachine().call(48, callArgs_340); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[25] = memory.readInt((int) (iL[0] + 72) < 0 ? (iL[0] + 72) : (iL[0] + 72) + 0); + iL[31] = memory.readInt((int) (iL[0] + 76) < 0 ? (iL[0] + 76) : (iL[0] + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[31], iL[25]) != 0) { + break _hb; + } + iL[27] = memory.readInt((int) 0 < 0 ? 0 : 0 + 61628); + label_304: while (true) { + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 20, (int) memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 16, (int) 26426); + long[] callArgs_341 = new long[4]; + callArgs_341[3] = ((long) (iL[23] + 16)); + callArgs_341[2] = ((long) 10479); + callArgs_341[1] = ((long) 128); + callArgs_341[0] = ((long) (iL[23] + 560)); + long[] callResult_341 = instance.getMachine().call(1865, callArgs_341); + long[] callArgs_342 = new long[2]; + callArgs_342[1] = ((long) (iL[23] + 560)); + callArgs_342[0] = ((long) iL[0]); + instance.getMachine().call(52, callArgs_342); + long[] callArgs_343 = new long[3]; + callArgs_343[2] = ((long) 1579); + callArgs_343[1] = ((long) memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 4)); + callArgs_343[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_343); + iL[37] = (iL[25] + 12); + long[] callArgs_344 = new long[3]; + callArgs_344[2] = ((long) 8765); + callArgs_344[1] = ((long) ((memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0) - memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 8)) >> 4)); + callArgs_344[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_344); + label_305: { + iL[24] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 8); + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_305; + } + label_306: while (true) { + long[] callArgs_345 = new long[3]; + callArgs_345[2] = ((long) 16347); + callArgs_345[1] = ((long) memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0)); + callArgs_345[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_345); + long[] callArgs_346 = new long[3]; + callArgs_346[2] = ((long) 7277); + callArgs_346[1] = ((long) memory.readInt((int) (iL[24] + 4) < 0 ? (iL[24] + 4) : (iL[24] + 4) + 0)); + callArgs_346[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_346); + long[] callArgs_347 = new long[3]; + callArgs_347[2] = ((long) 2142); + callArgs_347[1] = ((long) memory.readInt((int) (iL[24] + 8) < 0 ? (iL[24] + 8) : (iL[24] + 8) + 0)); + callArgs_347[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_347); + label_307: { + label_308: { + label_309: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + iL[30] = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[37], 26); + if (iL[30] != 0) { + break label_309; + } + iL[38] = (1 << iL[37]); + if ((iL[38] & 48483128) != 0) { + break label_308; + } + if ((iL[38] & 85726407) != 0) { + break label_307; + } + } + iL[38] = 27457; + label_310: { + if (iL[30] != 0) { + break label_310; + } + iL[38] = memory.readInt((int) (62288 + (iL[37] << 2)) < 0 ? (62288 + (iL[37] << 2)) : (62288 + (iL[37] << 2)) + 0); + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 0, (int) iL[38]); + long[] callArgs_348 = new long[3]; + callArgs_348[2] = ((long) iL[23]); + callArgs_348[1] = ((long) 31608); + callArgs_348[0] = ((long) iL[27]); + long[] callResult_348 = instance.getMachine().call(1847, callArgs_348); + break label_307; + } + long[] callArgs_349 = new long[3]; + callArgs_349[2] = ((long) 17694); + callArgs_349[1] = ((long) memory.readInt((int) (iL[24] + 12) < 0 ? (iL[24] + 12) : (iL[24] + 12) + 0)); + callArgs_349[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_349); + } + iL[24] = (iL[24] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_306; + } + break; + } + } + long[] callArgs_350 = new long[4]; + callArgs_350[3] = ((long) 15012); + callArgs_350[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_350[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_350[0] = ((long) iL[0]); + long[] callResult_350 = instance.getMachine().call(48, callArgs_350); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[25] = (iL[25] + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[31], iL[25]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_304; + } + break; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h3(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_43: { + label_44: { + label_45: { + label_46: { + label_47: { + int _d2 = func_801__h2(iL, lL, memory, instance); + if (_d2 == 1) + break label_44; + if (_d2 == 2) + break label_45; + if (_d2 == 3) + break label_46; + if (_d2 == 4) + break _hb; + if (_d2 == 5) + break label_43; + if (_d2 >= 10000) { + _hs[0] = ((_d2 - 10000)) + 10000; + break _hb; + } + } + label_305: { + label_306: { + label_307: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_336 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 112)); + int ciFuncId_336 = instance.table(0).requiredRef(ciTableIdx_336); + com.dylibso.chicory.runtime.Instance ciRefInstance_336 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_336), instance); + if (!ciRefInstance_336.type(ciRefInstance_336.functionType(ciFuncId_336)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_336 = new long[2]; + callArgs_336[1] = ((long) iL[0]); + callArgs_336[0] = ((long) iL[3]); + long[] callResult_336 = ciRefInstance_336.getMachine().call(ciFuncId_336, callArgs_336); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_336[0])) != 0) { + break label_307; + } + long[] callArgs_337 = new long[3]; + callArgs_337[2] = ((long) 0); + callArgs_337[1] = ((long) 24375); + callArgs_337[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_337); + break label_306; + } + label_308: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_338 = new long[3]; + callArgs_338[2] = ((long) (iL[4] + 3168)); + callArgs_338[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_338[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_338 = instance.getMachine().call(177, callArgs_338); + iL[3] = ((int) callResult_338[0]); + if (iL[3] != 0) { + break label_308; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2112, (int) 6606); + long[] callArgs_339 = new long[3]; + callArgs_339[2] = ((long) (iL[4] + 2112)); + callArgs_339[1] = ((long) 11260); + callArgs_339[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_339); + break label_306; + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_309: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[0], iL[3]) != 0) { + break label_309; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2136, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2132, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2128, (int) 6606); + long[] callArgs_340 = new long[3]; + callArgs_340[2] = ((long) (iL[4] + 2128)); + callArgs_340[1] = ((long) 12552); + callArgs_340[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_340); + break label_306; + } + label_310: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_341 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 116)); + int ciFuncId_341 = instance.table(0).requiredRef(ciTableIdx_341); + com.dylibso.chicory.runtime.Instance ciRefInstance_341 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_341), instance); + if (!ciRefInstance_341.type(ciRefInstance_341.functionType(ciFuncId_341)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_341 = new long[2]; + callArgs_341[1] = ((long) iL[0]); + callArgs_341[0] = ((long) iL[3]); + long[] callResult_341 = ciRefInstance_341.getMachine().call(ciFuncId_341, callArgs_341); + if (((int) callResult_341[0]) != 0) { + break label_310; + } + label_311: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_311; + } + iL[3] = 0; + label_312: while (true) { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3052); + memory.writeI32((int) ((iL[4] + 3168) + 15) < 0 ? ((iL[4] + 3168) + 15) : ((iL[4] + 3168) + 15) + 0, (int) 0); + memory.writeLong((int) ((iL[4] + 3168) + 8) < 0 ? ((iL[4] + 3168) + 8) : ((iL[4] + 3168) + 8) + 0, (long) 0L); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_342 = new long[3]; + callArgs_342[2] = ((long) (iL[4] + 3168)); + callArgs_342[1] = ((long) (iL[4] + 3256)); + callArgs_342[0] = ((long) (iL[4] + 2936)); + long[] callResult_342 = instance.getMachine().call(808, callArgs_342); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_342[0])) != 0) { + break label_306; + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3248, (long) lL[0]); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[15] = memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 120); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 2152, (long) lL[0]); + label_313: { + int ciTableIdx_343 = (int) (iL[15]); + int ciFuncId_343 = instance.table(0).requiredRef(ciTableIdx_343); + com.dylibso.chicory.runtime.Instance ciRefInstance_343 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_343), instance); + if (!ciRefInstance_343.type(ciRefInstance_343.functionType(ciFuncId_343)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_343 = new long[4]; + callArgs_343[3] = ((long) (iL[4] + 3168)); + callArgs_343[2] = ((long) (iL[4] + 2152)); + callArgs_343[1] = ((long) (iL[3] + iL[13])); + callArgs_343[0] = ((long) iL[14]); + long[] callResult_343 = ciRefInstance_343.getMachine().call(ciFuncId_343, callArgs_343); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_343[0])) != 0) { + break label_313; + } + long[] callArgs_344 = new long[3]; + callArgs_344[2] = ((long) 0); + callArgs_344[1] = ((long) 25506); + callArgs_344[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_344); + break label_306; + } + iL[3] = (iL[3] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[3], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_312; + } + break; + } + } + label_314: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_345 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 124)); + int ciFuncId_345 = instance.table(0).requiredRef(ciTableIdx_345); + com.dylibso.chicory.runtime.Instance ciRefInstance_345 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_345), instance); + if (!ciRefInstance_345.type(ciRefInstance_345.functionType(ciFuncId_345)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_345 = new long[1]; + callArgs_345[0] = ((long) iL[3]); + long[] callResult_345 = ciRefInstance_345.getMachine().call(ciFuncId_345, callArgs_345); + if (((int) callResult_345[0]) != 0) { + break label_314; + } + iL[3] = 0; + break label_305; + } + long[] callArgs_346 = new long[3]; + callArgs_346[2] = ((long) 0); + callArgs_346[1] = ((long) 24409); + callArgs_346[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_346); + break label_306; + } + long[] callArgs_347 = new long[3]; + callArgs_347[2] = ((long) 0); + callArgs_347[1] = ((long) 19990); + callArgs_347[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_347); + } + iL[3] = 1; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 10009; + break _hb; + } + } + label_315: { + label_316: { + label_317: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_348 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 96)); + int ciFuncId_348 = instance.table(0).requiredRef(ciTableIdx_348); + com.dylibso.chicory.runtime.Instance ciRefInstance_348 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_348), instance); + if (!ciRefInstance_348.type(ciRefInstance_348.functionType(ciFuncId_348)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_348 = new long[2]; + callArgs_348[1] = ((long) iL[0]); + callArgs_348[0] = ((long) iL[3]); + long[] callResult_348 = ciRefInstance_348.getMachine().call(ciFuncId_348, callArgs_348); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_348[0])) != 0) { + break label_317; + } + long[] callArgs_349 = new long[3]; + callArgs_349[2] = ((long) 0); + callArgs_349[1] = ((long) 23689); + callArgs_349[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_349); + break label_316; + } + label_318: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_350 = new long[3]; + callArgs_350[2] = ((long) (iL[4] + 3168)); + callArgs_350[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_350[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_350 = instance.getMachine().call(177, callArgs_350); + iL[0] = ((int) callResult_350[0]); + if (iL[0] != 0) { + break label_318; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2064, (int) 6553); + long[] callArgs_351 = new long[3]; + callArgs_351[2] = ((long) (iL[4] + 2064)); + callArgs_351[1] = ((long) 11260); + callArgs_351[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_351); + break label_316; + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3068, (int) iL[3]); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_319: { + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_319; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2088, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2084, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2080, (int) 6553); + long[] callArgs_352 = new long[3]; + callArgs_352[2] = ((long) (iL[4] + 2080)); + callArgs_352[1] = ((long) 12552); + callArgs_352[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_352); + break label_316; + } + label_320: { + label_321: { + label_322: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_353 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 100)); + int ciFuncId_353 = instance.table(0).requiredRef(ciTableIdx_353); + com.dylibso.chicory.runtime.Instance ciRefInstance_353 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_353), instance); + if (!ciRefInstance_353.type(ciRefInstance_353.functionType(ciFuncId_353)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_353 = new long[2]; + callArgs_353[1] = ((long) iL[3]); + callArgs_353[0] = ((long) iL[0]); + long[] callResult_353 = ciRefInstance_353.getMachine().call(ciFuncId_353, callArgs_353); + if (((int) callResult_353[0]) != 0) { + break label_322; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3068)) != 0) { + break label_320; + } + iL[3] = 0; + break label_321; + } + long[] callArgs_354 = new long[3]; + callArgs_354[2] = ((long) 0); + callArgs_354[1] = ((long) 19672); + callArgs_354[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_354); + break label_316; + } + label_323: while (true) { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3048); + label_324: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_355 = new long[3]; + callArgs_355[2] = ((long) (iL[4] + 3168)); + callArgs_355[1] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_355[0] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_355 = instance.getMachine().call(177, callArgs_355); + iL[0] = ((int) callResult_355[0]); + if (iL[0] != 0) { + break label_324; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2096, (int) 1845); + long[] callArgs_356 = new long[3]; + callArgs_356[2] = ((long) (iL[4] + 2096)); + callArgs_356[1] = ((long) 11260); + callArgs_356[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_356); + break label_316; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0])); + label_325: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_357 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 104)); + int ciFuncId_357 = instance.table(0).requiredRef(ciTableIdx_357); + com.dylibso.chicory.runtime.Instance ciRefInstance_357 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_357), instance); + if (!ciRefInstance_357.type(ciRefInstance_357.functionType(ciFuncId_357)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_357 = new long[3]; + callArgs_357[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168)); + callArgs_357[1] = ((long) (iL[3] + iL[13])); + callArgs_357[0] = ((long) iL[0]); + long[] callResult_357 = ciRefInstance_357.getMachine().call(ciFuncId_357, callArgs_357); + if (((int) callResult_357[0]) != 0) { + break label_325; + } + iL[3] = (iL[3] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3068)) != 0) { + break label_320; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_323; + } + break; + } + long[] callArgs_358 = new long[3]; + callArgs_358[2] = ((long) 0); + callArgs_358[1] = ((long) 23017); + callArgs_358[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_358); + break label_316; + } + label_326: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_359 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 108)); + int ciFuncId_359 = instance.table(0).requiredRef(ciTableIdx_359); + com.dylibso.chicory.runtime.Instance ciRefInstance_359 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_359), instance); + if (!ciRefInstance_359.type(ciRefInstance_359.functionType(ciFuncId_359)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_359 = new long[1]; + callArgs_359[0] = ((long) iL[3]); + long[] callResult_359 = ciRefInstance_359.getMachine().call(ciFuncId_359, callArgs_359); + if (((int) callResult_359[0]) != 0) { + break label_326; + } + iL[3] = 0; + break label_315; + } + long[] callArgs_360 = new long[3]; + callArgs_360[2] = ((long) 0); + callArgs_360[1] = ((long) 23726); + callArgs_360[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_360); + } + iL[3] = 1; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 10009; + break _hb; + } + } + label_327: { + int _d12 = func_801__h12(iL, lL, memory, instance); + if (_d12 >= 10000) { + _hs[0] = (_d12 - 10000); + break _hb; + } + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 10009; + break _hb; + } + } + label_355: { + int _d8 = func_801__h8(iL, lL, memory, instance); + if (_d8 >= 10000) { + _hs[0] = (_d8 - 10000); + break _hb; + } + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 10009; + break _hb; + } + } + long[] callArgs_435 = new long[3]; + callArgs_435[2] = ((long) 6); + callArgs_435[1] = ((long) 13831); + callArgs_435[0] = ((long) iL[18]); + long[] callResult_435 = instance.getMachine().call(1889, callArgs_435); + if (((int) callResult_435[0]) != 0) { + break _hb; + } + label_409: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_436 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 740)); + int ciFuncId_436 = instance.table(0).requiredRef(ciTableIdx_436); + com.dylibso.chicory.runtime.Instance ciRefInstance_436 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_436), instance); + if (!ciRefInstance_436.type(ciRefInstance_436.functionType(ciFuncId_436)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_436 = new long[2]; + callArgs_436[1] = ((long) iL[0]); + callArgs_436[0] = ((long) iL[3]); + long[] callResult_436 = ciRefInstance_436.getMachine().call(ciFuncId_436, callArgs_436); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_436[0])) != 0) { + break label_409; + } + long[] callArgs_437 = new long[3]; + callArgs_437[2] = ((long) 0); + callArgs_437[1] = ((long) 24111); + callArgs_437[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_437); + { + _hs[0] = 10002; + break _hb; + } + } + label_410: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_438 = new long[3]; + callArgs_438[2] = ((long) (iL[4] + 3248)); + callArgs_438[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_438[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_438 = instance.getMachine().call(177, callArgs_438); + iL[0] = ((int) callResult_438[0]); + if (iL[0] != 0) { + break label_410; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1520, (int) 14889); + long[] callArgs_439 = new long[3]; + callArgs_439[2] = ((long) (iL[4] + 1520)); + callArgs_439[1] = ((long) 11260); + callArgs_439[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_439); + { + _hs[0] = 10002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_411: { + long[] callArgs_440 = new long[3]; + callArgs_440[2] = ((long) (iL[4] + 3240)); + callArgs_440[1] = ((long) (iL[3] + iL[13])); + callArgs_440[0] = ((long) (iL[3] + iL[0])); + long[] callResult_440 = instance.getMachine().call(177, callArgs_440); + iL[0] = ((int) callResult_440[0]); + if (iL[0] != 0) { + break label_411; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1536, (int) 12938); + long[] callArgs_441 = new long[3]; + callArgs_441[2] = ((long) (iL[4] + 1536)); + callArgs_441[1] = ((long) 11260); + callArgs_441[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_441); + { + _hs[0] = 10002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_412: { + long[] callArgs_442 = new long[3]; + callArgs_442[2] = ((long) (iL[4] + 3232)); + callArgs_442[1] = ((long) (iL[3] + iL[13])); + callArgs_442[0] = ((long) (iL[3] + iL[0])); + long[] callResult_442 = instance.getMachine().call(177, callArgs_442); + iL[0] = ((int) callResult_442[0]); + if (iL[0] != 0) { + break label_412; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1552, (int) 14898); + long[] callArgs_443 = new long[3]; + callArgs_443[2] = ((long) (iL[4] + 1552)); + callArgs_443[1] = ((long) 11260); + callArgs_443[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_443); + { + _hs[0] = 10002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_413: { + long[] callArgs_444 = new long[3]; + callArgs_444[2] = ((long) (iL[4] + 3224)); + callArgs_444[1] = ((long) (iL[3] + iL[13])); + callArgs_444[0] = ((long) (iL[3] + iL[0])); + long[] callResult_444 = instance.getMachine().call(177, callArgs_444); + iL[3] = ((int) callResult_444[0]); + if (iL[3] != 0) { + break label_413; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1568, (int) 12948); + long[] callArgs_445 = new long[3]; + callArgs_445[2] = ((long) (iL[4] + 1568)); + callArgs_445[1] = ((long) 11260); + callArgs_445[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_445); + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3])); + label_414: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_446 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 744)); + int ciFuncId_446 = instance.table(0).requiredRef(ciTableIdx_446); + com.dylibso.chicory.runtime.Instance ciRefInstance_446 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_446), instance); + if (!ciRefInstance_446.type(ciRefInstance_446.functionType(ciFuncId_446)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_446 = new long[5]; + callArgs_446[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3224)); + callArgs_446[3] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3232)); + callArgs_446[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3240)); + callArgs_446[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3248)); + callArgs_446[0] = ((long) iL[3]); + long[] callResult_446 = ciRefInstance_446.getMachine().call(ciFuncId_446, callArgs_446); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_446[0])) != 0) { + break label_414; + } + long[] callArgs_447 = new long[3]; + callArgs_447[2] = ((long) 0); + callArgs_447[1] = ((long) 22925); + callArgs_447[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_447); + { + _hs[0] = 10002; + break _hb; + } + } + label_415: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_448 = new long[3]; + callArgs_448[2] = ((long) (iL[4] + 3216)); + callArgs_448[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_448[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_448 = instance.getMachine().call(177, callArgs_448); + iL[3] = ((int) callResult_448[0]); + if (iL[3] != 0) { + break label_415; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1584, (int) 8776); + long[] callArgs_449 = new long[3]; + callArgs_449[2] = ((long) (iL[4] + 1584)); + callArgs_449[1] = ((long) 11260); + callArgs_449[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_449); + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3])); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_450 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 764)); + int ciFuncId_450 = instance.table(0).requiredRef(ciTableIdx_450); + com.dylibso.chicory.runtime.Instance ciRefInstance_450 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_450), instance); + if (!ciRefInstance_450.type(ciRefInstance_450.functionType(ciFuncId_450)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_450 = new long[2]; + callArgs_450[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3216)); + callArgs_450[0] = ((long) iL[3]); + long[] callResult_450 = ciRefInstance_450.getMachine().call(ciFuncId_450, callArgs_450); + if (((int) callResult_450[0]) != 0) { + { + _hs[0] = 10000; + break _hb; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3216); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3216, (int) (iL[3] + -1)); + label_416: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_416; + } + label_417: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_451 = new long[3]; + callArgs_451[2] = ((long) 16783); + callArgs_451[1] = ((long) (iL[4] + 3168)); + callArgs_451[0] = ((long) (iL[4] + 2936)); + long[] callResult_451 = instance.getMachine().call(803, callArgs_451); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_451[0])) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) lL[0]); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[0] = memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 768); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1592, (long) lL[0]); + label_418: { + int ciTableIdx_452 = (int) (iL[0]); + int ciFuncId_452 = instance.table(0).requiredRef(ciTableIdx_452); + com.dylibso.chicory.runtime.Instance ciRefInstance_452 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_452), instance); + if (!ciRefInstance_452.type(ciRefInstance_452.functionType(ciFuncId_452)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_452 = new long[2]; + callArgs_452[1] = ((long) (iL[4] + 1592)); + callArgs_452[0] = ((long) iL[3]); + long[] callResult_452 = ciRefInstance_452.getMachine().call(ciFuncId_452, callArgs_452); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_452[0])) != 0) { + break label_418; + } + long[] callArgs_453 = new long[3]; + callArgs_453[2] = ((long) 0); + callArgs_453[1] = ((long) 25555); + callArgs_453[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_453); + { + _hs[0] = 10002; + break _hb; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3216); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3216, (int) (iL[3] + -1)); + if (iL[3] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_417; + } + break; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_454 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 772)); + int ciFuncId_454 = instance.table(0).requiredRef(ciTableIdx_454); + com.dylibso.chicory.runtime.Instance ciRefInstance_454 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_454), instance); + if (!ciRefInstance_454.type(ciRefInstance_454.functionType(ciFuncId_454)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_454 = new long[1]; + callArgs_454[0] = ((long) iL[3]); + long[] callResult_454 = ciRefInstance_454.getMachine().call(ciFuncId_454, callArgs_454); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_454[0])) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + long[] callArgs_455 = new long[3]; + callArgs_455[2] = ((long) 0); + callArgs_455[1] = ((long) 24146); + callArgs_455[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_455); + { + _hs[0] = 10002; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h3(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_74: { + label_75: { + label_76: { + label_77: { + label_78: { + label_79: { + label_80: { + int _d8 = func_804__h8(iL, lL, memory, instance); + if (_d8 == 1) + break label_74; + if (_d8 == 2) + break label_79; + if (_d8 == 3) + break label_78; + if (_d8 == 4) + break label_77; + if (_d8 == 5) + break label_76; + if (_d8 == 6) + break label_75; + if (_d8 >= 10000) { + _hs[0] = (_d8 - 10000); + break _hb; + } + } + iL[11] = 1; + long[] callArgs_242 = new long[8]; + callArgs_242[7] = ((long) 0); + callArgs_242[6] = ((long) 7228); + callArgs_242[5] = ((long) 2348); + callArgs_242[4] = ((long) 6846); + callArgs_242[3] = ((long) (iL[3] + 336)); + callArgs_242[2] = ((long) (iL[3] + 348)); + callArgs_242[1] = ((long) (iL[3] + 352)); + callArgs_242[0] = ((long) iL[0]); + long[] callResult_242 = instance.getMachine().call(827, callArgs_242); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_242[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + label_232: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_243 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 296)); + int ciFuncId_243 = instance.table(0).requiredRef(ciTableIdx_243); + com.dylibso.chicory.runtime.Instance ciRefInstance_243 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_243), instance); + if (!ciRefInstance_243.type(ciRefInstance_243.functionType(ciFuncId_243)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_243 = new long[5]; + callArgs_243[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_243[3] = lL[0]; + callArgs_243[2] = ((long) iL[12]); + callArgs_243[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_243[0] = ((long) iL[4]); + long[] callResult_243 = ciRefInstance_243.getMachine().call(ciFuncId_243, callArgs_243); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_243[0])) != 0) { + break label_232; + } + long[] callArgs_244 = new long[3]; + callArgs_244[2] = ((long) 0); + callArgs_244[1] = ((long) 21195); + callArgs_244[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_244); + { + _hs[0] = 10007; + break _hb; + } + } + long[] callArgs_245 = new long[5]; + callArgs_245[4] = ((long) 0); + callArgs_245[3] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_245[2] = ((long) iL[12]); + callArgs_245[1] = lL[0]; + callArgs_245[0] = ((long) iL[0]); + long[] callResult_245 = instance.getMachine().call(829, callArgs_245); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_245[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + { + _hs[0] = 10007; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_246 = new long[3]; + callArgs_246[2] = ((long) 13430); + callArgs_246[1] = ((long) (iL[3] + 352)); + callArgs_246[0] = ((long) iL[0]); + long[] callResult_246 = instance.getMachine().call(811, callArgs_246); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_246[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + label_233: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 352) & 0xFF)) != 0) { + break label_233; + } + iL[4] = 28541; + { + _hs[0] = 10039; + break _hb; + } + } + label_234: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_247 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 300)); + int ciFuncId_247 = instance.table(0).requiredRef(ciTableIdx_247); + com.dylibso.chicory.runtime.Instance ciRefInstance_247 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_247), instance); + if (!ciRefInstance_247.type(ciRefInstance_247.functionType(ciFuncId_247)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_247 = new long[2]; + callArgs_247[1] = ((long) 0); + callArgs_247[0] = ((long) iL[4]); + long[] callResult_247 = ciRefInstance_247.getMachine().call(ciFuncId_247, callArgs_247); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_247[0])) != 0) { + break label_234; + } + iL[4] = 22745; + { + _hs[0] = 10039; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_248 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 232)); + int ciFuncId_248 = instance.table(0).requiredRef(ciTableIdx_248); + com.dylibso.chicory.runtime.Instance ciRefInstance_248 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_248), instance); + if (!ciRefInstance_248.type(ciRefInstance_248.functionType(ciFuncId_248)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_248 = new long[2]; + callArgs_248[1] = ((long) 0); + callArgs_248[0] = ((long) iL[4]); + long[] callResult_248 = ciRefInstance_248.getMachine().call(ciFuncId_248, callArgs_248); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_248[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25792; + { + _hs[0] = 10039; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_249 = new long[8]; + callArgs_249[7] = ((long) 0); + callArgs_249[6] = ((long) 7265); + callArgs_249[5] = ((long) 2411); + callArgs_249[4] = ((long) 6877); + callArgs_249[3] = ((long) (iL[3] + 336)); + callArgs_249[2] = ((long) (iL[3] + 348)); + callArgs_249[1] = ((long) (iL[3] + 352)); + callArgs_249[0] = ((long) iL[0]); + long[] callResult_249 = instance.getMachine().call(827, callArgs_249); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_249[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + label_235: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_250 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 280)); + int ciFuncId_250 = instance.table(0).requiredRef(ciTableIdx_250); + com.dylibso.chicory.runtime.Instance ciRefInstance_250 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_250), instance); + if (!ciRefInstance_250.type(ciRefInstance_250.functionType(ciFuncId_250)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_250 = new long[5]; + callArgs_250[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_250[3] = lL[0]; + callArgs_250[2] = ((long) iL[4]); + callArgs_250[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_250[0] = ((long) iL[12]); + long[] callResult_250 = ciRefInstance_250.getMachine().call(ciFuncId_250, callArgs_250); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_250[0])) != 0) { + break label_235; + } + iL[4] = 22832; + { + _hs[0] = 10040; + break _hb; + } + } + iL[12] = (int) lL[0]; + iL[10] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[14] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[13] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + label_236: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_236; + } + int ciTableIdx_251 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 248)); + int ciFuncId_251 = instance.table(0).requiredRef(ciTableIdx_251); + com.dylibso.chicory.runtime.Instance ciRefInstance_251 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_251), instance); + if (!ciRefInstance_251.type(ciRefInstance_251.functionType(ciFuncId_251)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_251 = new long[4]; + callArgs_251[3] = ((long) iL[13]); + callArgs_251[2] = ((long) iL[4]); + callArgs_251[1] = ((long) iL[12]); + callArgs_251[0] = ((long) iL[10]); + long[] callResult_251 = ciRefInstance_251.getMachine().call(ciFuncId_251, callArgs_251); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_251[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25860; + { + _hs[0] = 10040; + break _hb; + } + } + int ciTableIdx_252 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 244)); + int ciFuncId_252 = instance.table(0).requiredRef(ciTableIdx_252); + com.dylibso.chicory.runtime.Instance ciRefInstance_252 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_252), instance); + if (!ciRefInstance_252.type(ciRefInstance_252.functionType(ciFuncId_252)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_252 = new long[3]; + callArgs_252[2] = ((long) iL[13]); + callArgs_252[1] = ((long) iL[12]); + callArgs_252[0] = ((long) iL[10]); + long[] callResult_252 = ciRefInstance_252.getMachine().call(ciFuncId_252, callArgs_252); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_252[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25823; + { + _hs[0] = 10040; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_253 = new long[8]; + callArgs_253[7] = ((long) 0); + callArgs_253[6] = ((long) 7240); + callArgs_253[5] = ((long) 2398); + callArgs_253[4] = ((long) 6861); + callArgs_253[3] = ((long) (iL[3] + 336)); + callArgs_253[2] = ((long) (iL[3] + 348)); + callArgs_253[1] = ((long) (iL[3] + 352)); + callArgs_253[0] = ((long) iL[0]); + long[] callResult_253 = instance.getMachine().call(827, callArgs_253); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_253[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + label_237: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_254 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 284)); + int ciFuncId_254 = instance.table(0).requiredRef(ciTableIdx_254); + com.dylibso.chicory.runtime.Instance ciRefInstance_254 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_254), instance); + if (!ciRefInstance_254.type(ciRefInstance_254.functionType(ciFuncId_254)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_254 = new long[5]; + callArgs_254[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_254[3] = lL[0]; + callArgs_254[2] = ((long) iL[4]); + callArgs_254[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_254[0] = ((long) iL[12]); + long[] callResult_254 = ciRefInstance_254.getMachine().call(ciFuncId_254, callArgs_254); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_254[0])) != 0) { + break label_237; + } + iL[4] = 22484; + { + _hs[0] = 10041; + break _hb; + } + } + iL[12] = (int) lL[0]; + iL[10] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[14] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[13] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + label_238: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_238; + } + int ciTableIdx_255 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 248)); + int ciFuncId_255 = instance.table(0).requiredRef(ciTableIdx_255); + com.dylibso.chicory.runtime.Instance ciRefInstance_255 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_255), instance); + if (!ciRefInstance_255.type(ciRefInstance_255.functionType(ciFuncId_255)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_255 = new long[4]; + callArgs_255[3] = ((long) iL[13]); + callArgs_255[2] = ((long) iL[4]); + callArgs_255[1] = ((long) iL[12]); + callArgs_255[0] = ((long) iL[10]); + long[] callResult_255 = ciRefInstance_255.getMachine().call(ciFuncId_255, callArgs_255); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_255[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25860; + { + _hs[0] = 10041; + break _hb; + } + } + int ciTableIdx_256 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 244)); + int ciFuncId_256 = instance.table(0).requiredRef(ciTableIdx_256); + com.dylibso.chicory.runtime.Instance ciRefInstance_256 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_256), instance); + if (!ciRefInstance_256.type(ciRefInstance_256.functionType(ciFuncId_256)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_256 = new long[3]; + callArgs_256[2] = ((long) iL[13]); + callArgs_256[1] = ((long) iL[12]); + callArgs_256[0] = ((long) iL[10]); + long[] callResult_256 = ciRefInstance_256.getMachine().call(ciFuncId_256, callArgs_256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_256[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25823; + { + _hs[0] = 10041; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_257 = new long[8]; + callArgs_257[7] = ((long) 0); + callArgs_257[6] = ((long) 7200); + callArgs_257[5] = ((long) 2282); + callArgs_257[4] = ((long) 6794); + callArgs_257[3] = ((long) (iL[3] + 336)); + callArgs_257[2] = ((long) (iL[3] + 348)); + callArgs_257[1] = ((long) (iL[3] + 352)); + callArgs_257[0] = ((long) iL[0]); + long[] callResult_257 = instance.getMachine().call(827, callArgs_257); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_257[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + label_239: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_258 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 288)); + int ciFuncId_258 = instance.table(0).requiredRef(ciTableIdx_258); + com.dylibso.chicory.runtime.Instance ciRefInstance_258 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_258), instance); + if (!ciRefInstance_258.type(ciRefInstance_258.functionType(ciFuncId_258)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_258 = new long[5]; + callArgs_258[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_258[3] = lL[0]; + callArgs_258[2] = ((long) iL[4]); + callArgs_258[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_258[0] = ((long) iL[12]); + long[] callResult_258 = ciRefInstance_258.getMachine().call(ciFuncId_258, callArgs_258); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_258[0])) != 0) { + break label_239; + } + iL[4] = 20682; + { + _hs[0] = 10042; + break _hb; + } + } + iL[12] = (int) lL[0]; + iL[10] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[14] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[13] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + label_240: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_240; + } + int ciTableIdx_259 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 248)); + int ciFuncId_259 = instance.table(0).requiredRef(ciTableIdx_259); + com.dylibso.chicory.runtime.Instance ciRefInstance_259 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_259), instance); + if (!ciRefInstance_259.type(ciRefInstance_259.functionType(ciFuncId_259)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_259 = new long[4]; + callArgs_259[3] = ((long) iL[13]); + callArgs_259[2] = ((long) iL[4]); + callArgs_259[1] = ((long) iL[12]); + callArgs_259[0] = ((long) iL[10]); + long[] callResult_259 = ciRefInstance_259.getMachine().call(ciFuncId_259, callArgs_259); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_259[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25860; + { + _hs[0] = 10042; + break _hb; + } + } + int ciTableIdx_260 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 244)); + int ciFuncId_260 = instance.table(0).requiredRef(ciTableIdx_260); + com.dylibso.chicory.runtime.Instance ciRefInstance_260 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_260), instance); + if (!ciRefInstance_260.type(ciRefInstance_260.functionType(ciFuncId_260)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_260 = new long[3]; + callArgs_260[2] = ((long) iL[13]); + callArgs_260[1] = ((long) iL[12]); + callArgs_260[0] = ((long) iL[10]); + long[] callResult_260 = ciRefInstance_260.getMachine().call(ciFuncId_260, callArgs_260); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_260[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25823; + { + _hs[0] = 10042; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_261 = new long[8]; + callArgs_261[7] = ((long) 0); + callArgs_261[6] = ((long) 7200); + callArgs_261[5] = ((long) 2282); + callArgs_261[4] = ((long) 6794); + callArgs_261[3] = ((long) (iL[3] + 336)); + callArgs_261[2] = ((long) (iL[3] + 348)); + callArgs_261[1] = ((long) (iL[3] + 352)); + callArgs_261[0] = ((long) iL[0]); + long[] callResult_261 = instance.getMachine().call(827, callArgs_261); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_261[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + label_241: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_262 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 292)); + int ciFuncId_262 = instance.table(0).requiredRef(ciTableIdx_262); + com.dylibso.chicory.runtime.Instance ciRefInstance_262 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_262), instance); + if (!ciRefInstance_262.type(ciRefInstance_262.functionType(ciFuncId_262)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_262 = new long[5]; + callArgs_262[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_262[3] = lL[0]; + callArgs_262[2] = ((long) iL[4]); + callArgs_262[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_262[0] = ((long) iL[12]); + long[] callResult_262 = ciRefInstance_262.getMachine().call(ciFuncId_262, callArgs_262); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_262[0])) != 0) { + break label_241; + } + iL[4] = 22181; + { + _hs[0] = 10043; + break _hb; + } + } + iL[12] = (int) lL[0]; + iL[10] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[14] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[13] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + label_242: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_242; + } + int ciTableIdx_263 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 248)); + int ciFuncId_263 = instance.table(0).requiredRef(ciTableIdx_263); + com.dylibso.chicory.runtime.Instance ciRefInstance_263 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_263), instance); + if (!ciRefInstance_263.type(ciRefInstance_263.functionType(ciFuncId_263)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_263 = new long[4]; + callArgs_263[3] = ((long) iL[13]); + callArgs_263[2] = ((long) iL[4]); + callArgs_263[1] = ((long) iL[12]); + callArgs_263[0] = ((long) iL[10]); + long[] callResult_263 = ciRefInstance_263.getMachine().call(ciFuncId_263, callArgs_263); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_263[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25860; + { + _hs[0] = 10043; + break _hb; + } + } + int ciTableIdx_264 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 244)); + int ciFuncId_264 = instance.table(0).requiredRef(ciTableIdx_264); + com.dylibso.chicory.runtime.Instance ciRefInstance_264 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_264), instance); + if (!ciRefInstance_264.type(ciRefInstance_264.functionType(ciFuncId_264)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_264 = new long[3]; + callArgs_264[2] = ((long) iL[13]); + callArgs_264[1] = ((long) iL[12]); + callArgs_264[0] = ((long) iL[10]); + long[] callResult_264 = ciRefInstance_264.getMachine().call(ciFuncId_264, callArgs_264); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_264[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25823; + { + _hs[0] = 10043; + break _hb; + } + } + label_243: { + long[] callArgs_265 = new long[3]; + callArgs_265[2] = ((long) 1473); + callArgs_265[1] = ((long) (iL[3] + 352)); + callArgs_265[0] = ((long) iL[0]); + long[] callResult_265 = instance.getMachine().call(814, callArgs_265); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_265[0])) != 0) { + break label_243; + } + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + label_244: { + long[] callArgs_266 = new long[3]; + callArgs_266[2] = ((long) 2109); + callArgs_266[1] = ((long) (iL[3] + 336)); + callArgs_266[0] = ((long) iL[0]); + long[] callResult_266 = instance.getMachine().call(814, callArgs_266); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_266[0])) != 0) { + break label_244; + } + label_245: { + label_246: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + iL[11] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + int ciTableIdx_267 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 456)); + int ciFuncId_267 = instance.table(0).requiredRef(ciTableIdx_267); + com.dylibso.chicory.runtime.Instance ciRefInstance_267 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_267), instance); + if (!ciRefInstance_267.type(ciRefInstance_267.functionType(ciFuncId_267)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_267 = new long[3]; + callArgs_267[2] = ((long) iL[11]); + callArgs_267[1] = ((long) iL[12]); + callArgs_267[0] = ((long) iL[4]); + long[] callResult_267 = ciRefInstance_267.getMachine().call(ciFuncId_267, callArgs_267); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_267[0])) != 0) { + break label_246; + } + iL[4] = 21163; + break label_245; + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_268 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 244)); + int ciFuncId_268 = instance.table(0).requiredRef(ciTableIdx_268); + com.dylibso.chicory.runtime.Instance ciRefInstance_268 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_268), instance); + if (!ciRefInstance_268.type(ciRefInstance_268.functionType(ciFuncId_268)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_268 = new long[3]; + callArgs_268[2] = ((long) iL[11]); + callArgs_268[1] = ((long) iL[12]); + callArgs_268[0] = ((long) iL[4]); + long[] callResult_268 = ciRefInstance_268.getMachine().call(ciFuncId_268, callArgs_268); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_268[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25823; + } + long[] callArgs_269 = new long[3]; + callArgs_269[2] = ((long) 0); + callArgs_269[1] = ((long) iL[4]); + callArgs_269[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_269); + } + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1176__h3(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_30: { + label_31: { + label_32: { + label_33: { + label_34: { + label_35: { + label_36: { + label_37: { + label_38: { + int _d2 = func_1176__h2(iL, memory, instance); + if (_d2 == 1) + break label_36; + if (_d2 == 2) + break label_31; + if (_d2 == 3) + break label_37; + if (_d2 == 4) + break label_33; + if (_d2 == 5) + break label_35; + if (_d2 == 6) + break label_34; + if (_d2 == 7) + break label_32; + if (_d2 == 8) { + _hs[0] = 1; + break _hb; + } + if (_d2 == 9) + break _hb; + if (_d2 == 10) { + _hs[0] = 2; + break _hb; + } + if (_d2 == 11) + break label_30; + if (_d2 == 12) { + _hs[0] = 3; + break _hb; + } + if (_d2 == 13) { + _hs[0] = 4; + break _hb; + } + if (_d2 >= 10000) { + _hs[0] = ((_d2 - 10000)) + 10000; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_73 = new long[2]; + callArgs_73[1] = ((long) (iL[2] + 1520)); + callArgs_73[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_73); + memory.writeLong((int) ((iL[2] + 344) + 8) < 0 ? ((iL[2] + 344) + 8) : ((iL[2] + 344) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) ((iL[2] + 344) + 16) < 0 ? ((iL[2] + 344) + 16) : ((iL[2] + 344) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 344, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_74 = new long[3]; + callArgs_74[2] = ((long) iL[1]); + callArgs_74[1] = ((long) (iL[2] + 344)); + callArgs_74[0] = ((long) iL[0]); + long[] callResult_74 = instance.getMachine().call(1275, callArgs_74); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_74[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_75 = new long[2]; + callArgs_75[1] = ((long) (iL[2] + 1520)); + callArgs_75[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_75); + memory.writeLong((int) ((iL[2] + 368) + 8) < 0 ? ((iL[2] + 368) + 8) : ((iL[2] + 368) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) ((iL[2] + 368) + 16) < 0 ? ((iL[2] + 368) + 16) : ((iL[2] + 368) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 368, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_76 = new long[3]; + callArgs_76[2] = ((long) iL[1]); + callArgs_76[1] = ((long) (iL[2] + 368)); + callArgs_76[0] = ((long) iL[0]); + long[] callResult_76 = instance.getMachine().call(1276, callArgs_76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_76[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_77 = new long[2]; + callArgs_77[1] = ((long) (iL[2] + 1520)); + callArgs_77[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_77); + memory.writeLong((int) ((iL[2] + 392) + 8) < 0 ? ((iL[2] + 392) + 8) : ((iL[2] + 392) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) ((iL[2] + 392) + 16) < 0 ? ((iL[2] + 392) + 16) : ((iL[2] + 392) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 392, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_78 = new long[3]; + callArgs_78[2] = ((long) iL[1]); + callArgs_78[1] = ((long) (iL[2] + 392)); + callArgs_78[0] = ((long) iL[0]); + long[] callResult_78 = instance.getMachine().call(1277, callArgs_78); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_78[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_79 = new long[2]; + callArgs_79[1] = ((long) (iL[2] + 1520)); + callArgs_79[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_79); + memory.writeLong((int) ((iL[2] + 416) + 8) < 0 ? ((iL[2] + 416) + 8) : ((iL[2] + 416) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) ((iL[2] + 416) + 16) < 0 ? ((iL[2] + 416) + 16) : ((iL[2] + 416) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 416, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_80 = new long[3]; + callArgs_80[2] = ((long) iL[1]); + callArgs_80[1] = ((long) (iL[2] + 416)); + callArgs_80[0] = ((long) iL[0]); + long[] callResult_80 = instance.getMachine().call(1278, callArgs_80); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_80[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 440) + 16) < 0 ? ((iL[2] + 440) + 16) : ((iL[2] + 440) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 440) + 8) < 0 ? ((iL[2] + 440) + 8) : ((iL[2] + 440) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 440, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_81 = new long[3]; + callArgs_81[2] = ((long) iL[1]); + callArgs_81[1] = ((long) (iL[2] + 440)); + callArgs_81[0] = ((long) iL[0]); + long[] callResult_81 = instance.getMachine().call(1279, callArgs_81); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_81[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 464) + 16) < 0 ? ((iL[2] + 464) + 16) : ((iL[2] + 464) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 464) + 8) < 0 ? ((iL[2] + 464) + 8) : ((iL[2] + 464) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 464, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_82 = new long[3]; + callArgs_82[2] = ((long) iL[1]); + callArgs_82[1] = ((long) (iL[2] + 464)); + callArgs_82[0] = ((long) iL[0]); + long[] callResult_82 = instance.getMachine().call(1280, callArgs_82); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_82[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_83 = new long[2]; + callArgs_83[1] = ((long) (iL[2] + 1520)); + callArgs_83[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_83); + long[] callArgs_84 = new long[3]; + callArgs_84[2] = ((long) (iL[2] + 1688)); + callArgs_84[1] = ((long) 0); + callArgs_84[0] = ((long) (iL[2] + 1520)); + long[] callResult_84 = instance.getMachine().call(155, callArgs_84); + iL[3] = ((int) callResult_84[0]); + long[] callArgs_85 = new long[3]; + callArgs_85[2] = ((long) (iL[2] + 1688)); + callArgs_85[1] = ((long) 0); + callArgs_85[0] = ((long) (iL[2] + 1480)); + long[] callResult_85 = instance.getMachine().call(155, callArgs_85); + iL[5] = ((int) callResult_85[0]); + label_70: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12) + 10) & 0xFF)) != 0) { + break label_70; + } + long[] callArgs_86 = new long[2]; + callArgs_86[1] = ((long) iL[3]); + callArgs_86[0] = ((long) (iL[2] + 1440)); + long[] callResult_86 = instance.getMachine().call(159, callArgs_86); + iL[4] = ((int) callResult_86[0]); + long[] callArgs_87 = new long[3]; + callArgs_87[2] = ((long) iL[4]); + callArgs_87[1] = ((long) iL[3]); + callArgs_87[0] = ((long) iL[0]); + long[] callResult_87 = instance.getMachine().call(1170, callArgs_87); + long[] callArgs_88 = new long[1]; + callArgs_88[0] = ((long) iL[4]); + long[] callResult_88 = instance.getMachine().call(162, callArgs_88); + long[] callArgs_89 = new long[2]; + callArgs_89[1] = ((long) iL[5]); + callArgs_89[0] = ((long) (iL[2] + 1400)); + long[] callResult_89 = instance.getMachine().call(159, callArgs_89); + iL[4] = ((int) callResult_89[0]); + long[] callArgs_90 = new long[3]; + callArgs_90[2] = ((long) iL[4]); + callArgs_90[1] = ((long) iL[5]); + callArgs_90[0] = ((long) iL[0]); + long[] callResult_90 = instance.getMachine().call(1170, callArgs_90); + long[] callArgs_91 = new long[1]; + callArgs_91[0] = ((long) iL[4]); + long[] callResult_91 = instance.getMachine().call(162, callArgs_91); + } + long[] callArgs_92 = new long[1]; + callArgs_92[0] = ((long) 108); + long[] callResult_92 = instance.getMachine().call(1776, callArgs_92); + long[] callArgs_93 = new long[4]; + callArgs_93[3] = ((long) (iL[2] + 1688)); + callArgs_93[2] = ((long) iL[5]); + callArgs_93[1] = ((long) iL[3]); + callArgs_93[0] = ((long) ((int) callResult_92[0])); + long[] callResult_93 = instance.getMachine().call(1281, callArgs_93); + iL[4] = ((int) callResult_93[0]); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + label_71: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_71; + } + int ciTableIdx_94 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_94 = instance.table(0).requiredRef(ciTableIdx_94); + com.dylibso.chicory.runtime.Instance ciRefInstance_94 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_94), instance); + if (!ciRefInstance_94.type(ciRefInstance_94.functionType(ciFuncId_94)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_94 = new long[1]; + callArgs_94[0] = ((long) iL[0]); + ciRefInstance_94.getMachine().call(ciFuncId_94, callArgs_94); + } + long[] callArgs_95 = new long[1]; + callArgs_95[0] = ((long) iL[5]); + long[] callResult_95 = instance.getMachine().call(162, callArgs_95); + long[] callArgs_96 = new long[1]; + callArgs_96[0] = ((long) iL[3]); + long[] callResult_96 = instance.getMachine().call(162, callArgs_96); + { + _hs[0] = 10020; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_97 = new long[2]; + callArgs_97[1] = ((long) (iL[2] + 1520)); + callArgs_97[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_97); + memory.writeLong((int) ((iL[2] + 488) + 8) < 0 ? ((iL[2] + 488) + 8) : ((iL[2] + 488) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) ((iL[2] + 488) + 16) < 0 ? ((iL[2] + 488) + 16) : ((iL[2] + 488) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 488, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_98 = new long[3]; + callArgs_98[2] = ((long) iL[1]); + callArgs_98[1] = ((long) (iL[2] + 488)); + callArgs_98[0] = ((long) iL[0]); + long[] callResult_98 = instance.getMachine().call(1282, callArgs_98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_98[0])) != 0) { + { + _hs[0] = 10020; + break _hb; + } + } + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10019; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_99 = new long[2]; + callArgs_99[1] = ((long) (iL[2] + 1520)); + callArgs_99[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_99); + label_72: { + long[] callArgs_100 = new long[3]; + callArgs_100[2] = ((long) (iL[2] + 1688)); + callArgs_100[1] = ((long) 0); + callArgs_100[0] = ((long) (iL[2] + 1520)); + long[] callResult_100 = instance.getMachine().call(155, callArgs_100); + iL[3] = ((int) callResult_100[0]); + long[] callArgs_101 = new long[2]; + callArgs_101[1] = ((long) iL[3]); + callArgs_101[0] = ((long) iL[0]); + long[] callResult_101 = instance.getMachine().call(1166, callArgs_101); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_101[0])) != 0) { + break label_72; + } + long[] callArgs_102 = new long[1]; + callArgs_102[0] = ((long) iL[3]); + long[] callResult_102 = instance.getMachine().call(162, callArgs_102); + { + _hs[0] = 10008; + break _hb; + } + } + long[] callArgs_103 = new long[3]; + callArgs_103[2] = ((long) (iL[2] + 1688)); + callArgs_103[1] = ((long) 0); + callArgs_103[0] = ((long) (iL[2] + 1480)); + long[] callResult_103 = instance.getMachine().call(155, callArgs_103); + iL[5] = ((int) callResult_103[0]); + long[] callArgs_104 = new long[2]; + callArgs_104[1] = ((long) iL[5]); + callArgs_104[0] = ((long) (iL[2] + 1360)); + long[] callResult_104 = instance.getMachine().call(159, callArgs_104); + iL[4] = ((int) callResult_104[0]); + long[] callArgs_105 = new long[3]; + callArgs_105[2] = ((long) iL[4]); + callArgs_105[1] = ((long) iL[5]); + callArgs_105[0] = ((long) iL[0]); + long[] callResult_105 = instance.getMachine().call(1170, callArgs_105); + iL[0] = ((int) callResult_105[0]); + long[] callArgs_106 = new long[1]; + callArgs_106[0] = ((long) iL[4]); + long[] callResult_106 = instance.getMachine().call(162, callArgs_106); + label_73: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_73; + } + long[] callArgs_107 = new long[2]; + callArgs_107[1] = ((long) iL[5]); + callArgs_107[0] = ((long) iL[3]); + instance.getMachine().call(1283, callArgs_107); + } + long[] callArgs_108 = new long[1]; + callArgs_108[0] = ((long) 108); + long[] callResult_108 = instance.getMachine().call(1776, callArgs_108); + long[] callArgs_109 = new long[4]; + callArgs_109[3] = ((long) (iL[2] + 1688)); + callArgs_109[2] = ((long) iL[5]); + callArgs_109[1] = ((long) iL[3]); + callArgs_109[0] = ((long) ((int) callResult_108[0])); + long[] callResult_109 = instance.getMachine().call(1284, callArgs_109); + iL[4] = ((int) callResult_109[0]); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[4]); + label_74: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_74; + } + int ciTableIdx_110 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_110 = instance.table(0).requiredRef(ciTableIdx_110); + com.dylibso.chicory.runtime.Instance ciRefInstance_110 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_110), instance); + if (!ciRefInstance_110.type(ciRefInstance_110.functionType(ciFuncId_110)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_110 = new long[1]; + callArgs_110[0] = ((long) iL[0]); + ciRefInstance_110.getMachine().call(ciFuncId_110, callArgs_110); + } + long[] callArgs_111 = new long[1]; + callArgs_111[0] = ((long) iL[5]); + long[] callResult_111 = instance.getMachine().call(162, callArgs_111); + long[] callArgs_112 = new long[1]; + callArgs_112[0] = ((long) iL[3]); + long[] callResult_112 = instance.getMachine().call(162, callArgs_112); + { + _hs[0] = 10020; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1183__h2(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_95: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[9], 2047) != 0) { + break label_95; + } + iL[10] = ((iL[9] >>> 6) | -64); + label_96: { + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[5]) != 0) { + break label_96; + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (iL[10])); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[0] + 1)); + break _hb; + } + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[14] = (iL[0] - iL[4]); + iL[13] = (iL[14] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[13], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_97: { + label_98: { + iL[5] = (iL[5] - iL[4]); + iL[15] = (iL[5] << 1); + iL[15] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[5], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[15], iL[13]) != 0 ? iL[15] : iL[13]) : 2147483647); + if (iL[15] != 0) { + break label_98; + } + iL[13] = 0; + break label_97; + } + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) iL[15]); + long[] callResult_19 = instance.getMachine().call(1776, callArgs_19); + iL[13] = ((int) callResult_19[0]); + } + iL[5] = (iL[13] + iL[14]); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (iL[10])); + iL[15] = (iL[13] + iL[15]); + iL[16] = (iL[5] + 1); + label_99: { + label_100: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], iL[0]) != 0) { + break label_100; + } + iL[13] = iL[5]; + break label_99; + } + iL[17] = ((iL[4] ^ -1) + iL[0]); + label_101: { + iL[10] = (iL[14] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[10]) != 0) { + break label_101; + } + label_102: while (true) { + iL[5] = (iL[5] + -1); + iL[0] = (iL[0] + -1); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF))); + iL[10] = (iL[10] + -1); + if (iL[10] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_102; + } + break; + } + } + label_103: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[17], 3) != 0) { + break label_103; + } + iL[5] = (iL[5] + -4); + label_104: while (true) { + memory.writeByte((int) (iL[5] + 3) < 0 ? (iL[5] + 3) : (iL[5] + 3) + 0, (byte) (((int) memory.read((int) (iL[0] + -1) < 0 ? (iL[0] + -1) : (iL[0] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[5] + 2) < 0 ? (iL[5] + 2) : (iL[5] + 2) + 0, (byte) (((int) memory.read((int) (iL[0] + -2) < 0 ? (iL[0] + -2) : (iL[0] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[5] + 1) < 0 ? (iL[5] + 1) : (iL[5] + 1) + 0, (byte) (((int) memory.read((int) (iL[0] + -3) < 0 ? (iL[0] + -3) : (iL[0] + -3) + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF))); + iL[5] = (iL[5] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_104; + } + break; + } + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[16]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[13]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break _hb; + } + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) iL[0]); + instance.getMachine().call(1777, callArgs_20); + break _hb; + } + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + label_105: { + label_106: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[9], 65535) != 0) { + break label_106; + } + iL[10] = ((iL[9] >>> 12) | -32); + label_107: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[5]) != 0) { + break label_107; + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (iL[10])); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[0] + 1)); + break label_105; + } + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[14] = (iL[0] - iL[4]); + iL[13] = (iL[14] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[13], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_108: { + label_109: { + iL[5] = (iL[5] - iL[4]); + iL[15] = (iL[5] << 1); + iL[15] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[5], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[15], iL[13]) != 0 ? iL[15] : iL[13]) : 2147483647); + if (iL[15] != 0) { + break label_109; + } + iL[13] = 0; + break label_108; + } + long[] callArgs_21 = new long[1]; + callArgs_21[0] = ((long) iL[15]); + long[] callResult_21 = instance.getMachine().call(1776, callArgs_21); + iL[13] = ((int) callResult_21[0]); + } + iL[5] = (iL[13] + iL[14]); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (iL[10])); + iL[15] = (iL[13] + iL[15]); + iL[16] = (iL[5] + 1); + label_110: { + label_111: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], iL[0]) != 0) { + break label_111; + } + iL[13] = iL[5]; + break label_110; + } + iL[17] = ((iL[4] ^ -1) + iL[0]); + label_112: { + iL[10] = (iL[14] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[10]) != 0) { + break label_112; + } + label_113: while (true) { + iL[5] = (iL[5] + -1); + iL[0] = (iL[0] + -1); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF))); + iL[10] = (iL[10] + -1); + if (iL[10] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_113; + } + break; + } + } + label_114: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[17], 3) != 0) { + break label_114; + } + iL[5] = (iL[5] + -4); + label_115: while (true) { + memory.writeByte((int) (iL[5] + 3) < 0 ? (iL[5] + 3) : (iL[5] + 3) + 0, (byte) (((int) memory.read((int) (iL[0] + -1) < 0 ? (iL[0] + -1) : (iL[0] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[5] + 2) < 0 ? (iL[5] + 2) : (iL[5] + 2) + 0, (byte) (((int) memory.read((int) (iL[0] + -2) < 0 ? (iL[0] + -2) : (iL[0] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[5] + 1) < 0 ? (iL[5] + 1) : (iL[5] + 1) + 0, (byte) (((int) memory.read((int) (iL[0] + -3) < 0 ? (iL[0] + -3) : (iL[0] + -3) + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF))); + iL[5] = (iL[5] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_115; + } + break; + } + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[16]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[13]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_105; + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) iL[0]); + instance.getMachine().call(1777, callArgs_22); + break label_105; + } + iL[4] = ((iL[9] >>> 18) | -16); + label_116: { + label_117: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[5]) != 0) { + break label_117; + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (iL[4])); + iL[5] = (iL[0] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[5]); + break label_116; + } + iL[13] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[15] = (iL[0] - iL[13]); + iL[10] = (iL[15] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[10], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_118: { + label_119: { + iL[5] = (iL[5] - iL[13]); + iL[14] = (iL[5] << 1); + iL[5] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[5], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[14], iL[10]) != 0 ? iL[14] : iL[10]) : 2147483647); + if (iL[5] != 0) { + break label_119; + } + iL[14] = 0; + break label_118; + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) iL[5]); + long[] callResult_23 = instance.getMachine().call(1776, callArgs_23); + iL[14] = ((int) callResult_23[0]); + } + iL[10] = (iL[14] + iL[15]); + memory.writeByte((int) iL[10] < 0 ? iL[10] : iL[10] + 0, (byte) (iL[4])); + iL[16] = (iL[14] + iL[5]); + iL[5] = (iL[10] + 1); + label_120: { + label_121: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[13], iL[0]) != 0) { + break label_121; + } + iL[14] = iL[10]; + break label_120; + } + iL[17] = ((iL[13] ^ -1) + iL[0]); + label_122: { + iL[4] = (iL[15] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_122; + } + label_123: while (true) { + iL[10] = (iL[10] + -1); + iL[0] = (iL[0] + -1); + memory.writeByte((int) iL[10] < 0 ? iL[10] : iL[10] + 0, (byte) (((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF))); + iL[4] = (iL[4] + -1); + if (iL[4] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_123; + } + break; + } + } + label_124: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[17], 3) != 0) { + break label_124; + } + iL[10] = (iL[10] + -4); + label_125: while (true) { + memory.writeByte((int) (iL[10] + 3) < 0 ? (iL[10] + 3) : (iL[10] + 3) + 0, (byte) (((int) memory.read((int) (iL[0] + -1) < 0 ? (iL[0] + -1) : (iL[0] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[10] + 2) < 0 ? (iL[10] + 2) : (iL[10] + 2) + 0, (byte) (((int) memory.read((int) (iL[0] + -2) < 0 ? (iL[0] + -2) : (iL[0] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[10] + 1) < 0 ? (iL[10] + 1) : (iL[10] + 1) + 0, (byte) (((int) memory.read((int) (iL[0] + -3) < 0 ? (iL[0] + -3) : (iL[0] + -3) + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + memory.writeByte((int) iL[10] < 0 ? iL[10] : iL[10] + 0, (byte) (((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF))); + iL[10] = (iL[10] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[13], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_125; + } + break; + } + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[16]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[5]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[14]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_116; + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) iL[0]); + instance.getMachine().call(1777, callArgs_24); + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + } + iL[10] = (((iL[9] >>> 12) & 63) | -128); + label_126: { + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[5], iL[0]) != 0) { + break label_126; + } + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (iL[10])); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[5] + 1)); + break label_105; + } + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[14] = (iL[5] - iL[4]); + iL[13] = (iL[14] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[13], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_127: { + label_128: { + iL[0] = (iL[0] - iL[4]); + iL[15] = (iL[0] << 1); + iL[15] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[15], iL[13]) != 0 ? iL[15] : iL[13]) : 2147483647); + if (iL[15] != 0) { + break label_128; + } + iL[13] = 0; + break label_127; + } + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) iL[15]); + long[] callResult_25 = instance.getMachine().call(1776, callArgs_25); + iL[13] = ((int) callResult_25[0]); + } + iL[0] = (iL[13] + iL[14]); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (iL[10])); + iL[15] = (iL[13] + iL[15]); + iL[16] = (iL[0] + 1); + label_129: { + label_130: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], iL[5]) != 0) { + break label_130; + } + iL[13] = iL[0]; + break label_129; + } + iL[17] = ((iL[4] ^ -1) + iL[5]); + label_131: { + iL[10] = (iL[14] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[10]) != 0) { + break label_131; + } + label_132: while (true) { + iL[0] = (iL[0] + -1); + iL[5] = (iL[5] + -1); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 0) & 0xFF))); + iL[10] = (iL[10] + -1); + if (iL[10] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_132; + } + break; + } + } + label_133: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[17], 3) != 0) { + break label_133; + } + iL[0] = (iL[0] + -4); + label_134: while (true) { + memory.writeByte((int) (iL[0] + 3) < 0 ? (iL[0] + 3) : (iL[0] + 3) + 0, (byte) (((int) memory.read((int) (iL[5] + -1) < 0 ? (iL[5] + -1) : (iL[5] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 2) < 0 ? (iL[0] + 2) : (iL[0] + 2) + 0, (byte) (((int) memory.read((int) (iL[5] + -2) < 0 ? (iL[5] + -2) : (iL[5] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[0] + 1) < 0 ? (iL[0] + 1) : (iL[0] + 1) + 0, (byte) (((int) memory.read((int) (iL[5] + -3) < 0 ? (iL[5] + -3) : (iL[5] + -3) + 0) & 0xFF))); + iL[5] = (iL[5] + -4); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (((int) memory.read((int) iL[5] < 0 ? iL[5] : iL[5] + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], iL[5]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_134; + } + break; + } + } + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[16]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[13]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[5]) != 0) { + break label_105; + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) iL[5]); + instance.getMachine().call(1777, callArgs_26); + } + iL[10] = (((iL[9] >>> 6) & 63) | -128); + label_135: { + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[5] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[0], iL[5]) != 0) { + break label_135; + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (byte) (iL[10])); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) (iL[0] + 1)); + break _hb; + } + iL[4] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[14] = (iL[0] - iL[4]); + iL[13] = (iL[14] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[13], -1) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + label_136: { + label_137: { + iL[5] = (iL[5] - iL[4]); + iL[15] = (iL[5] << 1); + iL[15] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[5], 1073741823) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[15], iL[13]) != 0 ? iL[15] : iL[13]) : 2147483647); + if (iL[15] != 0) { + break label_137; + } + iL[13] = 0; + break label_136; + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) iL[15]); + long[] callResult_27 = instance.getMachine().call(1776, callArgs_27); + iL[13] = ((int) callResult_27[0]); + } + iL[5] = (iL[13] + iL[14]); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (iL[10])); + iL[15] = (iL[13] + iL[15]); + iL[16] = (iL[5] + 1); + label_138: { + label_139: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], iL[0]) != 0) { + break label_139; + } + iL[13] = iL[5]; + break label_138; + } + iL[17] = ((iL[4] ^ -1) + iL[0]); + label_140: { + iL[10] = (iL[14] & 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[10]) != 0) { + break label_140; + } + label_141: while (true) { + iL[5] = (iL[5] + -1); + iL[0] = (iL[0] + -1); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF))); + iL[10] = (iL[10] + -1); + if (iL[10] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_141; + } + break; + } + } + label_142: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[17], 3) != 0) { + break label_142; + } + iL[5] = (iL[5] + -4); + label_143: while (true) { + memory.writeByte((int) (iL[5] + 3) < 0 ? (iL[5] + 3) : (iL[5] + 3) + 0, (byte) (((int) memory.read((int) (iL[0] + -1) < 0 ? (iL[0] + -1) : (iL[0] + -1) + 0) & 0xFF))); + memory.writeByte((int) (iL[5] + 2) < 0 ? (iL[5] + 2) : (iL[5] + 2) + 0, (byte) (((int) memory.read((int) (iL[0] + -2) < 0 ? (iL[0] + -2) : (iL[0] + -2) + 0) & 0xFF))); + memory.writeByte((int) (iL[5] + 1) < 0 ? (iL[5] + 1) : (iL[5] + 1) + 0, (byte) (((int) memory.read((int) (iL[0] + -3) < 0 ? (iL[0] + -3) : (iL[0] + -3) + 0) & 0xFF))); + iL[0] = (iL[0] + -4); + memory.writeByte((int) iL[5] < 0 ? iL[5] : iL[5] + 0, (byte) (((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF))); + iL[5] = (iL[5] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_143; + } + break; + } + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + } + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 8, (int) iL[15]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 4, (int) iL[16]); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[13]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break _hb; + } + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) iL[0]); + instance.getMachine().call(1777, callArgs_28); + } while (false); + return _hs[0]; + } + + private static int func_1871__h3(int[] iL, long[] lL, double[] dL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_13: { + iL[20] = ((int) memory.read((int) iL[21] < 0 ? iL[21] : iL[21] + 0) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[20]) != 0) { + break label_13; + } + iL[1] = iL[21]; + label_14: while (true) { + label_15: { + label_16: { + label_17: { + iL[20] = (iL[20] & 255); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[20]) != 0) { + break label_17; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(37, iL[20]) != 0) { + break label_15; + } + iL[22] = iL[1]; + iL[20] = iL[1]; + label_18: while (true) { + label_19: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(37, ((int) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 1) & 0xFF)) != 0) { + break label_19; + } + iL[1] = iL[20]; + break label_16; + } + iL[22] = (iL[22] + 1); + iL[23] = ((int) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 2) & 0xFF); + iL[1] = (iL[20] + 2); + iL[20] = iL[1]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(37, iL[23]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_18; + } + break label_16; + } + } + iL[22] = iL[1]; + } + iL[20] = (iL[22] - iL[21]); + iL[22] = (iL[19] ^ 2147483647); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[20], iL[22]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + label_20: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_20; + } + if ((((int) memory.read((int) iL[0] < 0 ? iL[0] : iL[0] + 0) & 0xFF) & 32) != 0) { + break label_20; + } + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) iL[0]); + callArgs_0[1] = ((long) iL[20]); + callArgs_0[0] = ((long) iL[21]); + long[] callResult_0 = instance.getMachine().call(1855, callArgs_0); + } + if (iL[20] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 10002; + break _hb; + } + } + iL[20] = (iL[1] + 1); + iL[24] = -1; + label_21: { + iL[25] = (int) (byte) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 1); + iL[23] = (iL[25] + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[23], 9) != 0) { + break label_21; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(36, ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 2) & 0xFF)) != 0) { + break label_21; + } + iL[20] = (iL[1] + 3); + iL[25] = (int) (byte) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 3); + iL[18] = 1; + iL[24] = iL[23]; + } + iL[26] = 0; + label_22: { + iL[1] = (iL[25] + -32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[1], 31) != 0) { + break label_22; + } + iL[1] = (1 << iL[1]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[1] & 75913)) != 0) { + break label_22; + } + iL[23] = (iL[20] + 1); + iL[26] = 0; + label_23: while (true) { + iL[26] = (iL[1] | iL[26]); + iL[20] = iL[23]; + iL[25] = (int) (byte) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 0); + iL[1] = (iL[25] + -32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[1], 32) != 0) { + break label_22; + } + iL[23] = (iL[20] + 1); + iL[1] = (1 << iL[1]); + if ((iL[1] & 75913) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_23; + } + break; + } + } + label_24: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(42, iL[25]) != 0) { + break label_24; + } + label_25: { + label_26: { + iL[1] = ((int) (byte) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 1) + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[1], 9) != 0) { + break label_26; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(36, ((int) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 2) & 0xFF)) != 0) { + break label_26; + } + memory.writeI32((int) (iL[4] + (iL[1] << 2)) < 0 ? (iL[4] + (iL[1] << 2)) : (iL[4] + (iL[1] << 2)) + 0, (int) 10); + iL[23] = (iL[20] + 3); + iL[27] = memory.readInt((int) ((((int) (byte) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 1) << 3) + iL[3]) + -384) < 0 ? ((((int) (byte) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 1) << 3) + iL[3]) + -384) : ((((int) (byte) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 1) << 3) + iL[3]) + -384) + 0); + iL[18] = 1; + break label_25; + } + if (iL[18] != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[23] = (iL[20] + 1); + label_27: { + if (iL[0] != 0) { + break label_27; + } + iL[18] = 0; + iL[27] = 0; + break _hb; + } + iL[1] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 0); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 0, (int) (iL[1] + 4)); + iL[27] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + iL[18] = 0; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[27], -1) != 0) { + break _hb; + } + iL[27] = (0 - iL[27]); + iL[26] = (iL[26] | 8192); + break _hb; + } + iL[27] = 0; + label_28: { + iL[1] = (iL[25] + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[1], 9) != 0) { + break label_28; + } + iL[23] = iL[20]; + break _hb; + } + iL[27] = 0; + label_29: while (true) { + label_30: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[27], 214748364) != 0) { + break label_30; + } + iL[23] = (iL[27] * 10); + iL[27] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[1], (iL[23] ^ 2147483647)) != 0 ? -1 : (iL[23] + iL[1])); + iL[1] = (int) (byte) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 1); + iL[23] = (iL[20] + 1); + iL[20] = iL[23]; + iL[1] = (iL[1] + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1], 10) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_29; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[27], 0) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + break _hb; + } + iL[1] = (int) (byte) memory.read((int) iL[20] < 0 ? iL[20] : iL[20] + 1); + iL[27] = -1; + iL[20] = (iL[20] + 1); + iL[1] = (iL[1] + -48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[1], 10) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_29; + } + { + _hs[0] = 10001; + break _hb; + } + } + } + iL[20] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 1) & 0xFF); + iL[1] = (iL[1] + 1); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_14; + } + } + if (iL[0] != 0) { + { + _hs[0] = 10003; + break _hb; + } + } + label_31: { + if (iL[18] != 0) { + break label_31; + } + iL[19] = 0; + { + _hs[0] = 10003; + break _hb; + } + } + label_32: { + label_33: { + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 4); + if (iL[1] != 0) { + break label_33; + } + iL[1] = 1; + break label_32; + } + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) iL[2]); + callArgs_1[1] = ((long) iL[1]); + callArgs_1[0] = ((long) (iL[3] + 8)); + instance.getMachine().call(1872, callArgs_1); + label_34: { + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 8); + if (iL[1] != 0) { + break label_34; + } + iL[1] = 2; + break label_32; + } + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) iL[2]); + callArgs_2[1] = ((long) iL[1]); + callArgs_2[0] = ((long) (iL[3] + 16)); + instance.getMachine().call(1872, callArgs_2); + label_35: { + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 12); + if (iL[1] != 0) { + break label_35; + } + iL[1] = 3; + break label_32; + } + long[] callArgs_3 = new long[3]; + callArgs_3[2] = ((long) iL[2]); + callArgs_3[1] = ((long) iL[1]); + callArgs_3[0] = ((long) (iL[3] + 24)); + instance.getMachine().call(1872, callArgs_3); + label_36: { + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 16); + if (iL[1] != 0) { + break label_36; + } + iL[1] = 4; + break label_32; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) iL[2]); + callArgs_4[1] = ((long) iL[1]); + callArgs_4[0] = ((long) (iL[3] + 32)); + instance.getMachine().call(1872, callArgs_4); + label_37: { + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 20); + if (iL[1] != 0) { + break label_37; + } + iL[1] = 5; + break label_32; + } + long[] callArgs_5 = new long[3]; + callArgs_5[2] = ((long) iL[2]); + callArgs_5[1] = ((long) iL[1]); + callArgs_5[0] = ((long) (iL[3] + 40)); + instance.getMachine().call(1872, callArgs_5); + label_38: { + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 24); + if (iL[1] != 0) { + break label_38; + } + iL[1] = 6; + break label_32; + } + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) iL[2]); + callArgs_6[1] = ((long) iL[1]); + callArgs_6[0] = ((long) (iL[3] + 48)); + instance.getMachine().call(1872, callArgs_6); + label_39: { + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 28); + if (iL[1] != 0) { + break label_39; + } + iL[1] = 7; + break label_32; + } + long[] callArgs_7 = new long[3]; + callArgs_7[2] = ((long) iL[2]); + callArgs_7[1] = ((long) iL[1]); + callArgs_7[0] = ((long) (iL[3] + 56)); + instance.getMachine().call(1872, callArgs_7); + label_40: { + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 32); + if (iL[1] != 0) { + break label_40; + } + iL[1] = 8; + break label_32; + } + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) iL[2]); + callArgs_8[1] = ((long) iL[1]); + callArgs_8[0] = ((long) (iL[3] + 64)); + instance.getMachine().call(1872, callArgs_8); + label_41: { + iL[1] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 36); + if (iL[1] != 0) { + break label_41; + } + iL[1] = 9; + break label_32; + } + long[] callArgs_9 = new long[3]; + callArgs_9[2] = ((long) iL[2]); + callArgs_9[1] = ((long) iL[1]); + callArgs_9[0] = ((long) (iL[3] + 72)); + instance.getMachine().call(1872, callArgs_9); + iL[19] = 1; + { + _hs[0] = 10003; + break _hb; + } + } + iL[1] = (iL[1] << 2); + label_42: while (true) { + if (memory.readInt((int) (iL[4] + iL[1]) < 0 ? (iL[4] + iL[1]) : (iL[4] + iL[1]) + 0) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[1] = (iL[1] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(40, iL[1]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_42; + } + break; + } + iL[19] = 1; + { + _hs[0] = 10003; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_41__h3(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_29: { + iL[24] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[24], memory.readInt((int) (iL[25] + 80) < 0 ? (iL[25] + 80) : (iL[25] + 80) + 0)) != 0) { + break label_29; + } + iL[27] = (iL[0] + 16); + iL[34] = (iL[0] + 20); + iL[38] = 0; + label_30: while (true) { + iL[36] = memory.readInt((int) (iL[24] + (iL[38] << 2)) < 0 ? (iL[24] + (iL[38] << 2)) : (iL[24] + (iL[38] << 2)) + 0); + iL[30] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 48); + iL[37] = 1; + label_31: { + iL[24] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 564); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_31; + } + label_32: while (true) { + label_33: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], iL[37]) != 0) { + break label_33; + } + label_34: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[37], iL[38]) != 0) { + break label_34; + } + iL[37] = 0; + break label_31; + } + iL[24] = (iL[24] + 4); + } + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + if (iL[24] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_32; + } + break; + } + iL[37] = 1; + } + iL[24] = memory.readInt((int) iL[36] < 0 ? iL[36] : iL[36] + 0); + iL[31] = ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 11) & 0xFF); + iL[22] = iL[31]; + iL[31] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[31]), 0); + iL[28] = (iL[31] != 0 ? memory.readInt((int) iL[36] < 0 ? iL[36] : iL[36] + 4) : iL[22]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 556, (int) iL[28]); + iL[24] = (iL[31] != 0 ? iL[24] : iL[36]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 552, (int) iL[24]); + label_35: { + label_36: { + label_37: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], iL[30]) != 0) { + break label_37; + } + label_38: { + label_39: { + if (iL[28] != 0) { + break label_39; + } + iL[31] = 6; + break label_38; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 556, (int) (iL[28] + -1)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 552, (int) (iL[24] + 1)); + iL[31] = 0; + } + if (iL[37] != 0) { + break label_35; + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) (iL[23] + 552)); + callArgs_11[0] = ((long) iL[26]); + long[] callResult_11 = instance.getMachine().call(44, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_11[0])) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[24] = (iL[31] | -92); + break label_36; + } + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 552, (long) 0L); + iL[24] = 48; + iL[31] = 16; + if (iL[37] != 0) { + break label_35; + } + } + iL[31] = iL[24]; + } + iL[24] = memory.readInt((int) iL[27] < 0 ? iL[27] : iL[27] + 0); + iL[28] = ((iL[24] - memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12)) >> 5); + label_40: { + label_41: { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 28); + iL[36] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[37], iL[36]) != 0) { + break label_41; + } + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (int) iL[28]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 28, (int) (iL[37] + 4)); + break label_40; + } + iL[30] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 24); + iL[33] = ((iL[37] - iL[30]) >> 2); + iL[29] = (iL[33] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[29], 1073741824) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + label_42: { + label_43: { + iL[36] = (iL[36] - iL[30]); + iL[32] = (iL[36] >>> 1); + iL[29] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[36], 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[32], iL[29]) != 0 ? iL[32] : iL[29]) : 1073741823); + if (iL[29] != 0) { + break label_43; + } + iL[32] = 0; + break label_42; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[29], 1073741824) != 0) { + break _hb; + } + long[] callArgs_12 = new long[1]; + callArgs_12[0] = ((long) (iL[29] << 2)); + long[] callResult_12 = instance.getMachine().call(1776, callArgs_12); + iL[32] = ((int) callResult_12[0]); + } + iL[36] = (iL[32] + (iL[33] << 2)); + memory.writeI32((int) iL[36] < 0 ? iL[36] : iL[36] + 0, (int) iL[28]); + iL[28] = (iL[32] + (iL[29] << 2)); + iL[29] = (iL[36] + 4); + label_44: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[37]) != 0) { + break label_44; + } + label_45: while (true) { + iL[36] = (iL[36] + -4); + iL[37] = (iL[37] + -4); + memory.writeI32((int) iL[36] < 0 ? iL[36] : iL[36] + 0, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_45; + } + break; + } + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) iL[28]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 28, (int) iL[29]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 24, (int) iL[36]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[30]) != 0) { + break label_40; + } + long[] callArgs_13 = new long[1]; + callArgs_13[0] = ((long) iL[30]); + instance.getMachine().call(1777, callArgs_13); + iL[24] = memory.readInt((int) iL[27] < 0 ? iL[27] : iL[27] + 0); + } + label_46: { + label_47: { + iL[37] = memory.readInt((int) iL[34] < 0 ? iL[34] : iL[34] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[24], iL[37]) != 0) { + break label_47; + } + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 0, (int) 0); + memory.writeLong((int) iL[24] < 0 ? iL[24] : iL[24] + 4, (long) memory.readLong((int) iL[23] < 0 ? iL[23] : iL[23] + 552)); + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 16, (int) iL[38]); + memory.writeByte((int) iL[24] < 0 ? iL[24] : iL[24] + 12, (byte) (iL[31])); + memory.writeI32((int) iL[27] < 0 ? iL[27] : iL[27] + 0, (int) (iL[24] + 32)); + break label_46; + } + iL[36] = memory.readInt((int) iL[26] < 0 ? iL[26] : iL[26] + 0); + iL[28] = ((iL[24] - iL[36]) >> 5); + iL[30] = (iL[28] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[30], 134217728) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + iL[37] = (iL[37] - iL[36]); + iL[29] = (iL[37] >>> 4); + iL[37] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[37], 2147483616) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[29], iL[30]) != 0 ? iL[29] : iL[30]) : 134217727); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[37], 134217728) != 0) { + break _hb; + } + iL[30] = (iL[37] << 5); + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) iL[30]); + long[] callResult_14 = instance.getMachine().call(1776, callArgs_14); + iL[29] = ((int) callResult_14[0]); + iL[37] = (iL[29] + (iL[28] << 5)); + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (int) 0); + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 16, (int) iL[38]); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 12, (byte) (iL[31])); + memory.writeLong((int) iL[37] < 0 ? iL[37] : iL[37] + 4, (long) memory.readLong((int) iL[23] < 0 ? iL[23] : iL[23] + 552)); + iL[30] = (iL[29] + iL[30]); + iL[31] = (iL[37] + 32); + label_48: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_48; + } + label_49: while (true) { + iL[37] = (iL[37] + -32); + iL[24] = (iL[24] + -32); + memory.writeLong((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (long) memory.readLong((int) iL[24] < 0 ? iL[24] : iL[24] + 0)); + memory.writeLong((int) (iL[37] + 24) < 0 ? (iL[37] + 24) : (iL[37] + 24) + 0, (long) memory.readLong((int) (iL[24] + 24) < 0 ? (iL[24] + 24) : (iL[24] + 24) + 0)); + memory.writeLong((int) (iL[37] + 16) < 0 ? (iL[37] + 16) : (iL[37] + 16) + 0, (long) memory.readLong((int) (iL[24] + 16) < 0 ? (iL[24] + 16) : (iL[24] + 16) + 0)); + memory.writeLong((int) (iL[37] + 8) < 0 ? (iL[37] + 8) : (iL[37] + 8) + 0, (long) memory.readLong((int) (iL[24] + 8) < 0 ? (iL[24] + 8) : (iL[24] + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_49; + } + break; + } + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[37]); + memory.writeI32((int) iL[34] < 0 ? iL[34] : iL[34] + 0, (int) iL[30]); + memory.writeI32((int) iL[27] < 0 ? iL[27] : iL[27] + 0, (int) iL[31]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[36]) != 0) { + break label_46; + } + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) iL[36]); + instance.getMachine().call(1777, callArgs_15); + } + iL[38] = (iL[38] + 1); + iL[24] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], ((memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 80) - iL[24]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_30; + } + break; + } + } + label_50: { + iL[24] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 136); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[24], memory.readInt((int) (iL[25] + 140) < 0 ? (iL[25] + 140) : (iL[25] + 140) + 0)) != 0) { + break label_50; + } + iL[27] = (iL[0] + 16); + iL[34] = (iL[0] + 20); + iL[38] = 0; + label_51: while (true) { + iL[36] = memory.readInt((int) (iL[24] + (iL[38] << 2)) < 0 ? (iL[24] + (iL[38] << 2)) : (iL[24] + (iL[38] << 2)) + 0); + iL[30] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 52); + iL[37] = 1; + label_52: { + iL[24] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 524); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_52; + } + label_53: while (true) { + label_54: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], iL[37]) != 0) { + break label_54; + } + label_55: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[37], iL[38]) != 0) { + break label_55; + } + iL[37] = 0; + break label_52; + } + iL[24] = (iL[24] + 4); + } + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + if (iL[24] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_53; + } + break; + } + iL[37] = 1; + } + iL[24] = memory.readInt((int) iL[36] < 0 ? iL[36] : iL[36] + 0); + iL[31] = ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 11) & 0xFF); + iL[21] = iL[31]; + iL[31] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[31]), 0); + iL[28] = (iL[31] != 0 ? memory.readInt((int) iL[36] < 0 ? iL[36] : iL[36] + 4) : iL[21]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 556, (int) iL[28]); + iL[24] = (iL[31] != 0 ? iL[24] : iL[36]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 552, (int) iL[24]); + label_56: { + label_57: { + label_58: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], iL[30]) != 0) { + break label_58; + } + label_59: { + label_60: { + if (iL[28] != 0) { + break label_60; + } + iL[31] = 6; + break label_59; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 556, (int) (iL[28] + -1)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 552, (int) (iL[24] + 1)); + iL[31] = 0; + } + if (iL[37] != 0) { + break label_56; + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) (iL[23] + 552)); + callArgs_16[0] = ((long) iL[26]); + long[] callResult_16 = instance.getMachine().call(44, callArgs_16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_16[0])) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[24] = (iL[31] | -92); + break label_57; + } + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 552, (long) 0L); + iL[24] = 48; + iL[31] = 16; + if (iL[37] != 0) { + break label_56; + } + } + iL[31] = iL[24]; + } + iL[24] = memory.readInt((int) iL[27] < 0 ? iL[27] : iL[27] + 0); + iL[28] = ((iL[24] - memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12)) >> 5); + label_61: { + label_62: { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 40); + iL[36] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[37], iL[36]) != 0) { + break label_62; + } + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (int) iL[28]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 40, (int) (iL[37] + 4)); + break label_61; + } + iL[30] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 36); + iL[33] = ((iL[37] - iL[30]) >> 2); + iL[29] = (iL[33] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[29], 1073741824) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + label_63: { + label_64: { + iL[36] = (iL[36] - iL[30]); + iL[32] = (iL[36] >>> 1); + iL[29] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[36], 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[32], iL[29]) != 0 ? iL[32] : iL[29]) : 1073741823); + if (iL[29] != 0) { + break label_64; + } + iL[32] = 0; + break label_63; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[29], 1073741824) != 0) { + break _hb; + } + long[] callArgs_17 = new long[1]; + callArgs_17[0] = ((long) (iL[29] << 2)); + long[] callResult_17 = instance.getMachine().call(1776, callArgs_17); + iL[32] = ((int) callResult_17[0]); + } + iL[36] = (iL[32] + (iL[33] << 2)); + memory.writeI32((int) iL[36] < 0 ? iL[36] : iL[36] + 0, (int) iL[28]); + iL[28] = (iL[32] + (iL[29] << 2)); + iL[29] = (iL[36] + 4); + label_65: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[37]) != 0) { + break label_65; + } + label_66: while (true) { + iL[36] = (iL[36] + -4); + iL[37] = (iL[37] + -4); + memory.writeI32((int) iL[36] < 0 ? iL[36] : iL[36] + 0, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_66; + } + break; + } + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 44, (int) iL[28]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 40, (int) iL[29]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 36, (int) iL[36]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[30]) != 0) { + break label_61; + } + long[] callArgs_18 = new long[1]; + callArgs_18[0] = ((long) iL[30]); + instance.getMachine().call(1777, callArgs_18); + iL[24] = memory.readInt((int) iL[27] < 0 ? iL[27] : iL[27] + 0); + } + label_67: { + label_68: { + iL[37] = memory.readInt((int) iL[34] < 0 ? iL[34] : iL[34] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[24], iL[37]) != 0) { + break label_68; + } + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 0, (int) 5); + memory.writeLong((int) iL[24] < 0 ? iL[24] : iL[24] + 4, (long) memory.readLong((int) iL[23] < 0 ? iL[23] : iL[23] + 552)); + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 16, (int) iL[38]); + memory.writeByte((int) iL[24] < 0 ? iL[24] : iL[24] + 12, (byte) (iL[31])); + memory.writeI32((int) iL[27] < 0 ? iL[27] : iL[27] + 0, (int) (iL[24] + 32)); + break label_67; + } + iL[36] = memory.readInt((int) iL[26] < 0 ? iL[26] : iL[26] + 0); + iL[28] = ((iL[24] - iL[36]) >> 5); + iL[30] = (iL[28] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[30], 134217728) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + iL[37] = (iL[37] - iL[36]); + iL[29] = (iL[37] >>> 4); + iL[37] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[37], 2147483616) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[29], iL[30]) != 0 ? iL[29] : iL[30]) : 134217727); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[37], 134217728) != 0) { + break _hb; + } + iL[30] = (iL[37] << 5); + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) iL[30]); + long[] callResult_19 = instance.getMachine().call(1776, callArgs_19); + iL[29] = ((int) callResult_19[0]); + iL[37] = (iL[29] + (iL[28] << 5)); + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (int) 5); + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 16, (int) iL[38]); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 12, (byte) (iL[31])); + memory.writeLong((int) iL[37] < 0 ? iL[37] : iL[37] + 4, (long) memory.readLong((int) iL[23] < 0 ? iL[23] : iL[23] + 552)); + iL[30] = (iL[29] + iL[30]); + iL[31] = (iL[37] + 32); + label_69: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_69; + } + label_70: while (true) { + iL[37] = (iL[37] + -32); + iL[24] = (iL[24] + -32); + memory.writeLong((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (long) memory.readLong((int) iL[24] < 0 ? iL[24] : iL[24] + 0)); + memory.writeLong((int) (iL[37] + 24) < 0 ? (iL[37] + 24) : (iL[37] + 24) + 0, (long) memory.readLong((int) (iL[24] + 24) < 0 ? (iL[24] + 24) : (iL[24] + 24) + 0)); + memory.writeLong((int) (iL[37] + 16) < 0 ? (iL[37] + 16) : (iL[37] + 16) + 0, (long) memory.readLong((int) (iL[24] + 16) < 0 ? (iL[24] + 16) : (iL[24] + 16) + 0)); + memory.writeLong((int) (iL[37] + 8) < 0 ? (iL[37] + 8) : (iL[37] + 8) + 0, (long) memory.readLong((int) (iL[24] + 8) < 0 ? (iL[24] + 8) : (iL[24] + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_70; + } + break; + } + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[37]); + memory.writeI32((int) iL[34] < 0 ? iL[34] : iL[34] + 0, (int) iL[30]); + memory.writeI32((int) iL[27] < 0 ? iL[27] : iL[27] + 0, (int) iL[31]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[36]) != 0) { + break label_67; + } + long[] callArgs_20 = new long[1]; + callArgs_20[0] = ((long) iL[36]); + instance.getMachine().call(1777, callArgs_20); + } + iL[38] = (iL[38] + 1); + iL[24] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 136); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], ((memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 140) - iL[24]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_51; + } + break; + } + } + label_71: { + iL[24] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[24], memory.readInt((int) (iL[25] + 92) < 0 ? (iL[25] + 92) : (iL[25] + 92) + 0)) != 0) { + break label_71; + } + iL[27] = (iL[0] + 16); + iL[34] = (iL[0] + 20); + iL[38] = 0; + label_72: while (true) { + iL[36] = memory.readInt((int) (iL[24] + (iL[38] << 2)) < 0 ? (iL[24] + (iL[38] << 2)) : (iL[24] + (iL[38] << 2)) + 0); + iL[30] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 60); + iL[37] = 1; + label_73: { + iL[24] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 388); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_73; + } + label_74: while (true) { + label_75: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], iL[37]) != 0) { + break label_75; + } + label_76: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[37], iL[38]) != 0) { + break label_76; + } + iL[37] = 0; + break label_73; + } + iL[24] = (iL[24] + 4); + } + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + if (iL[24] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_74; + } + break; + } + iL[37] = 1; + } + iL[24] = memory.readInt((int) iL[36] < 0 ? iL[36] : iL[36] + 0); + iL[31] = ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 11) & 0xFF); + iL[20] = iL[31]; + iL[31] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[31]), 0); + iL[28] = (iL[31] != 0 ? memory.readInt((int) iL[36] < 0 ? iL[36] : iL[36] + 4) : iL[20]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 556, (int) iL[28]); + iL[24] = (iL[31] != 0 ? iL[24] : iL[36]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 552, (int) iL[24]); + label_77: { + label_78: { + label_79: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], iL[30]) != 0) { + break label_79; + } + label_80: { + label_81: { + if (iL[28] != 0) { + break label_81; + } + iL[31] = 6; + break label_80; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 556, (int) (iL[28] + -1)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 552, (int) (iL[24] + 1)); + iL[31] = 0; + } + if (iL[37] != 0) { + break label_77; + } + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) (iL[23] + 552)); + callArgs_21[0] = ((long) iL[26]); + long[] callResult_21 = instance.getMachine().call(44, callArgs_21); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_21[0])) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[24] = (iL[31] | -92); + break label_78; + } + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 552, (long) 0L); + iL[24] = 48; + iL[31] = 16; + if (iL[37] != 0) { + break label_77; + } + } + iL[31] = iL[24]; + } + iL[24] = memory.readInt((int) iL[27] < 0 ? iL[27] : iL[27] + 0); + iL[28] = ((iL[24] - memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12)) >> 5); + label_82: { + label_83: { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 52); + iL[36] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[37], iL[36]) != 0) { + break label_83; + } + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (int) iL[28]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 52, (int) (iL[37] + 4)); + break label_82; + } + iL[30] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 48); + iL[33] = ((iL[37] - iL[30]) >> 2); + iL[29] = (iL[33] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[29], 1073741824) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + label_84: { + label_85: { + iL[36] = (iL[36] - iL[30]); + iL[32] = (iL[36] >>> 1); + iL[29] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[36], 2147483644) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[32], iL[29]) != 0 ? iL[32] : iL[29]) : 1073741823); + if (iL[29] != 0) { + break label_85; + } + iL[32] = 0; + break label_84; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[29], 1073741824) != 0) { + break _hb; + } + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) (iL[29] << 2)); + long[] callResult_22 = instance.getMachine().call(1776, callArgs_22); + iL[32] = ((int) callResult_22[0]); + } + iL[36] = (iL[32] + (iL[33] << 2)); + memory.writeI32((int) iL[36] < 0 ? iL[36] : iL[36] + 0, (int) iL[28]); + iL[28] = (iL[32] + (iL[29] << 2)); + iL[29] = (iL[36] + 4); + label_86: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[30], iL[37]) != 0) { + break label_86; + } + label_87: while (true) { + iL[36] = (iL[36] + -4); + iL[37] = (iL[37] + -4); + memory.writeI32((int) iL[36] < 0 ? iL[36] : iL[36] + 0, (int) memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[30], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_87; + } + break; + } + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 56, (int) iL[28]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 52, (int) iL[29]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 48, (int) iL[36]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[30]) != 0) { + break label_82; + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) iL[30]); + instance.getMachine().call(1777, callArgs_23); + iL[24] = memory.readInt((int) iL[27] < 0 ? iL[27] : iL[27] + 0); + } + label_88: { + label_89: { + iL[37] = memory.readInt((int) iL[34] < 0 ? iL[34] : iL[34] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[24], iL[37]) != 0) { + break label_89; + } + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 0, (int) 2); + memory.writeLong((int) iL[24] < 0 ? iL[24] : iL[24] + 4, (long) memory.readLong((int) iL[23] < 0 ? iL[23] : iL[23] + 552)); + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 16, (int) iL[38]); + memory.writeByte((int) iL[24] < 0 ? iL[24] : iL[24] + 12, (byte) (iL[31])); + memory.writeI32((int) iL[27] < 0 ? iL[27] : iL[27] + 0, (int) (iL[24] + 32)); + break label_88; + } + iL[36] = memory.readInt((int) iL[26] < 0 ? iL[26] : iL[26] + 0); + iL[29] = ((iL[24] - iL[36]) >> 5); + iL[30] = (iL[29] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[30], 134217728) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + iL[37] = (iL[37] - iL[36]); + iL[28] = (iL[37] >>> 4); + iL[37] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[37], 2147483616) != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[28], iL[30]) != 0 ? iL[28] : iL[30]) : 134217727); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[37], 134217728) != 0) { + break _hb; + } + iL[30] = (iL[37] << 5); + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) iL[30]); + long[] callResult_24 = instance.getMachine().call(1776, callArgs_24); + iL[28] = ((int) callResult_24[0]); + iL[37] = (iL[28] + (iL[29] << 5)); + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (int) 2); + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 16, (int) iL[38]); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 12, (byte) (iL[31])); + memory.writeLong((int) iL[37] < 0 ? iL[37] : iL[37] + 4, (long) memory.readLong((int) iL[23] < 0 ? iL[23] : iL[23] + 552)); + iL[30] = (iL[28] + iL[30]); + iL[31] = (iL[37] + 32); + label_90: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_90; + } + label_91: while (true) { + iL[37] = (iL[37] + -32); + iL[24] = (iL[24] + -32); + memory.writeLong((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (long) memory.readLong((int) iL[24] < 0 ? iL[24] : iL[24] + 0)); + memory.writeLong((int) (iL[37] + 24) < 0 ? (iL[37] + 24) : (iL[37] + 24) + 0, (long) memory.readLong((int) (iL[24] + 24) < 0 ? (iL[24] + 24) : (iL[24] + 24) + 0)); + memory.writeLong((int) (iL[37] + 16) < 0 ? (iL[37] + 16) : (iL[37] + 16) + 0, (long) memory.readLong((int) (iL[24] + 16) < 0 ? (iL[24] + 16) : (iL[24] + 16) + 0)); + memory.writeLong((int) (iL[37] + 8) < 0 ? (iL[37] + 8) : (iL[37] + 8) + 0, (long) memory.readLong((int) (iL[24] + 8) < 0 ? (iL[24] + 8) : (iL[24] + 8) + 0)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_91; + } + break; + } + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[37]); + memory.writeI32((int) iL[34] < 0 ? iL[34] : iL[34] + 0, (int) iL[30]); + memory.writeI32((int) iL[27] < 0 ? iL[27] : iL[27] + 0, (int) iL[31]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[36]) != 0) { + break label_88; + } + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) iL[36]); + instance.getMachine().call(1777, callArgs_25); + } + iL[38] = (iL[38] + 1); + iL[24] = memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[38], ((memory.readInt((int) iL[25] < 0 ? iL[25] : iL[25] + 92) - iL[24]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_72; + } + break; + } + } + iL[37] = 0; + { + _hs[0] = 3; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h4(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_38: { + label_39: { + label_40: { + label_41: { + int _d0 = func_801__h0(iL, lL, memory, instance); + if (_d0 == 1) { + _hs[0] = 1; + break _hb; + } + if (_d0 == 2) { + _hs[0] = 2; + break _hb; + } + if (_d0 == 3) { + _hs[0] = 3; + break _hb; + } + if (_d0 == 4) { + _hs[0] = 4; + break _hb; + } + if (_d0 == 5) { + _hs[0] = 5; + break _hb; + } + if (_d0 == 6) { + _hs[0] = 10000; + break _hb; + } + if (_d0 == 7) { + _hs[0] = 10001; + break _hb; + } + if (_d0 == 8) { + _hs[0] = 10002; + break _hb; + } + if (_d0 == 9) { + _hs[0] = 6; + break _hb; + } + if (_d0 == 10) + break label_39; + if (_d0 == 11) + break label_40; + if (_d0 == 12) + break _hb; + if (_d0 == 13) { + _hs[0] = 7; + break _hb; + } + if (_d0 == 14) { + _hs[0] = 8; + break _hb; + } + } + long[] callArgs_576 = new long[3]; + callArgs_576[2] = ((long) 0); + callArgs_576[1] = ((long) 20019); + callArgs_576[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_576); + { + _hs[0] = 2; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[19] < 0 ? iL[19] : iL[19] + 12) & 0xFF)) != 0) { + break _hb; + } + break label_38; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[19] < 0 ? iL[19] : iL[19] + 12) & 0xFF)) != 0) { + break _hb; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[17], 14) != 0) { + break _hb; + } + } + iL[13] = (iL[18] + iL[17]); + iL[3] = iL[18]; + label_507: while (true) { + long[] callArgs_577 = new long[3]; + callArgs_577[2] = ((long) (iL[17] + -13)); + callArgs_577[1] = ((long) 109); + callArgs_577[0] = ((long) iL[3]); + long[] callResult_577 = instance.getMachine().call(1888, callArgs_577); + iL[3] = ((int) callResult_577[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break _hb; + } + label_508: { + long[] callArgs_578 = new long[3]; + callArgs_578[2] = ((long) 14); + callArgs_578[1] = ((long) 29082); + callArgs_578[0] = ((long) iL[3]); + long[] callResult_578 = instance.getMachine().call(1889, callArgs_578); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_578[0])) != 0) { + break label_508; + } + iL[3] = (iL[3] + 1); + iL[17] = (iL[13] - iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[17], 14) != 0) { + break _hb; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_507; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[13], iL[3]) != 0) { + break _hb; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[18], iL[3]) != 0) { + break _hb; + } + lL[0] = (((lL[0] & -4294967296L) | com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U((iL[18] + 14))) + -60129542144L); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) lL[0]); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[13] = memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 884); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 840, (long) lL[0]); + label_509: { + int ciTableIdx_579 = (int) (iL[13]); + int ciFuncId_579 = instance.table(0).requiredRef(ciTableIdx_579); + com.dylibso.chicory.runtime.Instance ciRefInstance_579 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_579), instance); + if (!ciRefInstance_579.type(ciRefInstance_579.functionType(ciFuncId_579)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_579 = new long[3]; + callArgs_579[2] = ((long) iL[0]); + callArgs_579[1] = ((long) (iL[4] + 840)); + callArgs_579[0] = ((long) iL[3]); + long[] callResult_579 = ciRefInstance_579.getMachine().call(ciFuncId_579, callArgs_579); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_579[0])) != 0) { + break label_509; + } + long[] callArgs_580 = new long[3]; + callArgs_580[2] = ((long) 0); + callArgs_580[1] = ((long) 24571); + callArgs_580[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_580); + { + _hs[0] = 2; + break _hb; + } + } + label_510: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_581 = new long[3]; + callArgs_581[2] = ((long) (iL[4] + 3256)); + callArgs_581[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_581[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_581 = instance.getMachine().call(177, callArgs_581); + iL[3] = ((int) callResult_581[0]); + if (iL[3] != 0) { + break label_510; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 608, (int) 6356); + long[] callArgs_582 = new long[3]; + callArgs_582[2] = ((long) (iL[4] + 608)); + callArgs_582[1] = ((long) 11260); + callArgs_582[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_582); + { + _hs[0] = 2; + break _hb; + } + } + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_511: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_511; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 632, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 628, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 624, (int) 6356); + long[] callArgs_583 = new long[3]; + callArgs_583[2] = ((long) (iL[4] + 624)); + callArgs_583[1] = ((long) 12552); + callArgs_583[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_583); + { + _hs[0] = 2; + break _hb; + } + } + label_512: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_584 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 888)); + int ciFuncId_584 = instance.table(0).requiredRef(ciTableIdx_584); + com.dylibso.chicory.runtime.Instance ciRefInstance_584 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_584), instance); + if (!ciRefInstance_584.type(ciRefInstance_584.functionType(ciFuncId_584)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_584 = new long[2]; + callArgs_584[1] = ((long) iL[3]); + callArgs_584[0] = ((long) iL[0]); + long[] callResult_584 = ciRefInstance_584.getMachine().call(ciFuncId_584, callArgs_584); + if (((int) callResult_584[0]) != 0) { + break label_512; + } + label_513: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_513; + } + iL[19] = 0; + iL[0] = -1; + label_514: while (true) { + label_515: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_585 = new long[3]; + callArgs_585[2] = ((long) (iL[4] + 3256)); + callArgs_585[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_585[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_585 = instance.getMachine().call(177, callArgs_585); + iL[13] = ((int) callResult_585[0]); + if (iL[13] != 0) { + break label_515; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 640, (int) 1564); + long[] callArgs_586 = new long[3]; + callArgs_586[2] = ((long) (iL[4] + 640)); + callArgs_586[1] = ((long) 11260); + callArgs_586[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_586); + { + _hs[0] = 2; + break _hb; + } + } + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_516: { + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[15] = (iL[17] - iL[13]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[16], iL[15]) != 0) { + break label_516; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 664, (int) iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 660, (int) iL[16]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 656, (int) 1564); + long[] callArgs_587 = new long[3]; + callArgs_587[2] = ((long) (iL[4] + 656)); + callArgs_587[1] = ((long) 12552); + callArgs_587[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_587); + { + _hs[0] = 2; + break _hb; + } + } + label_517: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3048); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[16], iL[15]) != 0) { + break label_517; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 672, (int) iL[16]); + long[] callArgs_588 = new long[3]; + callArgs_588[2] = ((long) (iL[4] + 672)); + callArgs_588[1] = ((long) 30098); + callArgs_588[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_588); + { + _hs[0] = 2; + break _hb; + } + } + label_518: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3068) + iL[15])) != 0) { + break label_518; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 832, (int) iL[16]); + long[] callArgs_589 = new long[3]; + callArgs_589[2] = ((long) (iL[4] + 832)); + callArgs_589[1] = ((long) 5354); + callArgs_589[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_589); + { + _hs[0] = 2; + break _hb; + } + } + label_519: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[0], iL[16]) != 0) { + break label_519; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 688, (int) iL[0]); + long[] callArgs_590 = new long[3]; + callArgs_590[2] = ((long) (iL[4] + 688)); + callArgs_590[1] = ((long) 5325); + callArgs_590[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_590); + { + _hs[0] = 2; + break _hb; + } + } + label_520: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[0]) != 0) { + break label_520; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[16], iL[0]) != 0) { + break label_520; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 816, (int) iL[16]); + long[] callArgs_591 = new long[3]; + callArgs_591[2] = ((long) (iL[4] + 816)); + callArgs_591[1] = ((long) 5523); + callArgs_591[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_591); + { + _hs[0] = 2; + break _hb; + } + } + label_521: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_592 = new long[3]; + callArgs_592[2] = ((long) (iL[4] + 3256)); + callArgs_592[1] = ((long) (iL[0] + iL[17])); + callArgs_592[0] = ((long) (iL[0] + iL[13])); + long[] callResult_592 = instance.getMachine().call(177, callArgs_592); + iL[0] = ((int) callResult_592[0]); + if (iL[0] != 0) { + break label_521; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 704, (int) 6320); + long[] callArgs_593 = new long[3]; + callArgs_593[2] = ((long) (iL[4] + 704)); + callArgs_593[1] = ((long) 11260); + callArgs_593[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_593); + { + _hs[0] = 2; + break _hb; + } + } + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_522: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[15], iL[0]) != 0) { + break label_522; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 728, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 724, (int) iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 720, (int) 6320); + long[] callArgs_594 = new long[3]; + callArgs_594[2] = ((long) (iL[4] + 720)); + callArgs_594[1] = ((long) 12552); + callArgs_594[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_594); + { + _hs[0] = 2; + break _hb; + } + } + label_523: { + label_524: { + label_525: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_595 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 892)); + int ciFuncId_595 = instance.table(0).requiredRef(ciTableIdx_595); + com.dylibso.chicory.runtime.Instance ciRefInstance_595 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_595), instance); + if (!ciRefInstance_595.type(ciRefInstance_595.functionType(ciFuncId_595)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_595 = new long[3]; + callArgs_595[2] = ((long) iL[15]); + callArgs_595[1] = ((long) iL[16]); + callArgs_595[0] = ((long) iL[0]); + long[] callResult_595 = ciRefInstance_595.getMachine().call(ciFuncId_595, callArgs_595); + if (((int) callResult_595[0]) != 0) { + break label_525; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[15]) != 0) { + break label_523; + } + iL[0] = -1; + break label_524; + } + long[] callArgs_596 = new long[3]; + callArgs_596[2] = ((long) 0); + callArgs_596[1] = ((long) 20124); + callArgs_596[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_596); + { + _hs[0] = 2; + break _hb; + } + } + label_526: while (true) { + label_527: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_597 = new long[3]; + callArgs_597[2] = ((long) (iL[4] + 3256)); + callArgs_597[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_597[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_597 = instance.getMachine().call(177, callArgs_597); + iL[13] = ((int) callResult_597[0]); + if (iL[13] != 0) { + break label_527; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 736, (int) 7253); + long[] callArgs_598 = new long[3]; + callArgs_598[2] = ((long) (iL[4] + 736)); + callArgs_598[1] = ((long) 11260); + callArgs_598[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_598); + { + _hs[0] = 2; + break _hb; + } + } + iL[17] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[17]); + label_528: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[0], iL[13]) != 0) { + break label_528; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 752, (int) iL[0]); + long[] callArgs_599 = new long[3]; + callArgs_599[2] = ((long) (iL[4] + 752)); + callArgs_599[1] = ((long) 1316); + callArgs_599[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_599); + { + _hs[0] = 2; + break _hb; + } + } + label_529: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[0]) != 0) { + break label_529; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[13], iL[0]) != 0) { + break label_529; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 800, (int) iL[13]); + long[] callArgs_600 = new long[3]; + callArgs_600[2] = ((long) (iL[4] + 800)); + callArgs_600[1] = ((long) 1343); + callArgs_600[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_600); + { + _hs[0] = 2; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (int) 0); + label_530: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_601 = new long[3]; + callArgs_601[2] = ((long) (iL[4] + 3256)); + callArgs_601[1] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_601[0] = ((long) (iL[0] + iL[17])); + long[] callResult_601 = instance.getMachine().call(177, callArgs_601); + iL[0] = ((int) callResult_601[0]); + if (iL[0] != 0) { + break label_530; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 768, (int) 15187); + long[] callArgs_602 = new long[3]; + callArgs_602[2] = ((long) (iL[4] + 768)); + callArgs_602[1] = ((long) 11260); + callArgs_602[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_602); + { + _hs[0] = 2; + break _hb; + } + } + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_531: { + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + iL[18] = (iL[17] + iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[18], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)) != 0) { + break label_531; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 784, (int) 26747); + long[] callArgs_603 = new long[3]; + callArgs_603[2] = ((long) (iL[4] + 784)); + callArgs_603[1] = ((long) 11176); + callArgs_603[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_603); + { + _hs[0] = 2; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[18]); + label_532: { + iL[18] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_604 = (int) (memory.readInt((int) memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0) < 0 ? memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0) : memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0) + 896)); + int ciFuncId_604 = instance.table(0).requiredRef(ciTableIdx_604); + com.dylibso.chicory.runtime.Instance ciRefInstance_604 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_604), instance); + if (!ciRefInstance_604.type(ciRefInstance_604.functionType(ciFuncId_604)).typesMatch(instance.type(12))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_604 = new long[4]; + callArgs_604[3] = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(iL[17]); + callArgs_604[2] = ((long) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[0])); + callArgs_604[1] = ((long) iL[13]); + callArgs_604[0] = ((long) iL[18]); + long[] callResult_604 = ciRefInstance_604.getMachine().call(ciFuncId_604, callArgs_604); + if (((int) callResult_604[0]) != 0) { + break label_532; + } + iL[0] = iL[13]; + iL[15] = (iL[15] + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[15]) != 0) { + break label_523; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_526; + } + break; + } + long[] callArgs_605 = new long[3]; + callArgs_605[2] = ((long) 0); + callArgs_605[1] = ((long) 25639); + callArgs_605[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_605); + { + _hs[0] = 2; + break _hb; + } + } + iL[0] = iL[16]; + iL[19] = (iL[19] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[3], iL[19]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_514; + } + break; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_606 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 900)); + int ciFuncId_606 = instance.table(0).requiredRef(ciTableIdx_606); + com.dylibso.chicory.runtime.Instance ciRefInstance_606 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_606), instance); + if (!ciRefInstance_606.type(ciRefInstance_606.functionType(ciFuncId_606)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_606 = new long[1]; + callArgs_606[0] = ((long) iL[3]); + long[] callResult_606 = ciRefInstance_606.getMachine().call(ciFuncId_606, callArgs_606); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_606[0])) != 0) { + { + _hs[0] = 4; + break _hb; + } + } + long[] callArgs_607 = new long[3]; + callArgs_607[2] = ((long) 0); + callArgs_607[1] = ((long) 24612); + callArgs_607[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_607); + { + _hs[0] = 2; + break _hb; + } + } + long[] callArgs_608 = new long[3]; + callArgs_608[2] = ((long) 0); + callArgs_608[1] = ((long) 20084); + callArgs_608[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_608); + { + _hs[0] = 2; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h4(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_42: { + label_43: { + label_44: { + label_45: { + label_46: { + iL[4] = memory.readInt((int) (iL[0] + 12) < 0 ? (iL[0] + 12) : (iL[0] + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[4], iL[1]) != 0) { + break label_46; + } + iL[5] = (iL[0] + 52); + iL[6] = (iL[0] + 76); + iL[7] = (iL[0] + 88); + iL[8] = (iL[0] + 36); + iL[9] = (iL[0] + 100); + label_47: while (true) { + label_48: { + iL[10] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[4], iL[10]) != 0) { + break label_48; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 260, (int) 17512); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 256, (int) 7656); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) (iL[3] + 256)); + callArgs_0[1] = ((long) 10873); + callArgs_0[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_0); + iL[11] = 1; + { + _hs[0] = 10001; + break _hb; + } + } + iL[11] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + iL[12] = ((int) memory.read((int) (iL[11] + iL[4]) < 0 ? (iL[11] + iL[4]) : (iL[11] + iL[4]) + 0) & 0xFF); + iL[4] = (iL[4] + 1); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[4]); + label_49: { + label_50: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(((iL[12] + 4) & 255), 2) != 0) { + break label_50; + } + label_51: { + long[] callArgs_1 = new long[3]; + callArgs_1[2] = ((long) (iL[3] + 352)); + callArgs_1[1] = ((long) (iL[11] + iL[10])); + callArgs_1[0] = ((long) (iL[11] + iL[4])); + long[] callResult_1 = instance.getMachine().call(177, callArgs_1); + iL[4] = ((int) callResult_1[0]); + if (iL[4] != 0) { + break label_51; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 0, (int) 17512); + long[] callArgs_2 = new long[3]; + callArgs_2[2] = ((long) iL[3]); + callArgs_2[1] = ((long) 11260); + callArgs_2[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_2); + iL[11] = 1; + { + _hs[0] = 10001; + break _hb; + } + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12) + iL[4])); + iL[11] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + iL[12] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[11], 511) != 0 ? iL[11] : 511) | (iL[12] << 9)); + iL[4] = memory.readInt((int) (97296 + (iL[12] << 2)) < 0 ? (97296 + (iL[12] << 2)) : (97296 + (iL[12] << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[11]) != 0) { + break label_49; + } + if (iL[4] != 0) { + break label_49; + } + iL[4] = (0 - iL[12]); + break label_49; + } + iL[4] = memory.readInt((int) (97296 + (iL[12] << 2)) < 0 ? (97296 + (iL[12] << 2)) : (97296 + (iL[12] << 2)) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[12]) != 0) { + break label_49; + } + if (iL[4] != 0) { + break label_49; + } + iL[4] = (0 - iL[12]); + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 448, (int) iL[4]); + label_52: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 224)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) iL[4]); + callArgs_3[0] = ((long) iL[12]); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_3[0])) != 0) { + break label_52; + } + long[] callArgs_4 = new long[3]; + callArgs_4[2] = ((long) 0); + callArgs_4[1] = ((long) 25530); + callArgs_4[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_4); + iL[11] = 1; + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) memory.readInt((int) iL[9] < 0 ? iL[9] : iL[9] + 0)); + callArgs_5[0] = ((long) (iL[3] + 448)); + long[] callResult_5 = instance.getMachine().call(194, callArgs_5); + iL[12] = ((int) callResult_5[0]); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448); + label_53: { + if (iL[12] != 0) { + break label_53; + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) iL[4]); + callArgs_6[0] = ((long) iL[0]); + long[] callResult_6 = instance.getMachine().call(819, callArgs_6); + iL[11] = ((int) callResult_6[0]); + { + _hs[0] = 10001; + break _hb; + } + } + label_54: { + int _d9 = func_804__h9(iL, lL, memory, instance); + if (_d9 == 1) + break label_45; + if (_d9 == 2) + break label_42; + if (_d9 == 3) + break label_43; + if (_d9 == 4) + break label_44; + if (_d9 >= 10000) { + _hs[0] = (_d9 - 10000); + break _hb; + } + } + iL[4] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[4], iL[1]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_47; + } + break; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 16, (int) iL[2]); + long[] callArgs_334 = new long[3]; + callArgs_334[2] = ((long) (iL[3] + 16)); + callArgs_334[1] = ((long) 17491); + callArgs_334[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_334); + iL[11] = 1; + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_335 = new long[2]; + callArgs_335[1] = ((long) iL[4]); + callArgs_335[0] = ((long) iL[0]); + long[] callResult_335 = instance.getMachine().call(819, callArgs_335); + iL[11] = ((int) callResult_335[0]); + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_336 = new long[3]; + callArgs_336[2] = ((long) 0); + callArgs_336[1] = ((long) iL[4]); + callArgs_336[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_336); + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_337 = new long[3]; + callArgs_337[2] = ((long) 0); + callArgs_337[1] = ((long) iL[4]); + callArgs_337[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_337); + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_338 = new long[3]; + callArgs_338[2] = ((long) 0); + callArgs_338[1] = ((long) iL[4]); + callArgs_338[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_338); + { + _hs[0] = 10001; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1176__h4(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_18: { + label_19: { + label_20: { + label_21: { + label_22: { + label_23: { + label_24: { + int _d0 = func_1176__h0(iL, memory, instance); + if (_d0 == 1) + break _hb; + if (_d0 == 2) { + _hs[0] = 1; + break _hb; + } + if (_d0 == 3) + break label_18; + if (_d0 == 4) { + _hs[0] = 2; + break _hb; + } + if (_d0 == 5) { + _hs[0] = 10000; + break _hb; + } + if (_d0 == 6) { + _hs[0] = 3; + break _hb; + } + if (_d0 == 7) { + _hs[0] = 4; + break _hb; + } + if (_d0 == 8) { + _hs[0] = 10001; + break _hb; + } + if (_d0 == 9) + break label_22; + if (_d0 == 10) + break label_23; + if (_d0 == 11) + break label_19; + if (_d0 == 12) { + _hs[0] = 10002; + break _hb; + } + if (_d0 == 13) { + _hs[0] = 10003; + break _hb; + } + if (_d0 == 14) { + _hs[0] = 10004; + break _hb; + } + if (_d0 == 15) { + _hs[0] = 10005; + break _hb; + } + if (_d0 == 16) { + _hs[0] = 10006; + break _hb; + } + if (_d0 == 17) + break label_21; + if (_d0 == 18) + break label_20; + if (_d0 == 19) { + _hs[0] = 10007; + break _hb; + } + if (_d0 == 20) { + _hs[0] = 10008; + break _hb; + } + if (_d0 == 21) { + _hs[0] = 10009; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_158 = new long[2]; + callArgs_158[1] = ((long) (iL[2] + 1520)); + callArgs_158[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_158); + memory.writeLong((int) ((iL[2] + 512) + 8) < 0 ? ((iL[2] + 512) + 8) : ((iL[2] + 512) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) ((iL[2] + 512) + 16) < 0 ? ((iL[2] + 512) + 16) : ((iL[2] + 512) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 512, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_159 = new long[3]; + callArgs_159[2] = ((long) iL[1]); + callArgs_159[1] = ((long) (iL[2] + 512)); + callArgs_159[0] = ((long) iL[0]); + long[] callResult_159 = instance.getMachine().call(1285, callArgs_159); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_159[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + { + _hs[0] = 10001; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_160 = new long[2]; + callArgs_160[1] = ((long) (iL[2] + 1520)); + callArgs_160[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_160); + long[] callArgs_161 = new long[2]; + callArgs_161[1] = ((long) (iL[2] + 1520)); + callArgs_161[0] = ((long) iL[0]); + long[] callResult_161 = instance.getMachine().call(1194, callArgs_161); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_161[0])) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_162 = new long[1]; + callArgs_162[0] = ((long) 44); + long[] callResult_162 = instance.getMachine().call(1776, callArgs_162); + iL[0] = ((int) callResult_162[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 37); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 55676); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 36, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + int ciTableIdx_163 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_163 = instance.table(0).requiredRef(ciTableIdx_163); + com.dylibso.chicory.runtime.Instance ciRefInstance_163 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_163), instance); + if (!ciRefInstance_163.type(ciRefInstance_163.functionType(ciFuncId_163)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_163 = new long[1]; + callArgs_163[0] = ((long) iL[3]); + ciRefInstance_163.getMachine().call(ciFuncId_163, callArgs_163); + { + _hs[0] = 10008; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_164 = new long[2]; + callArgs_164[1] = ((long) (iL[2] + 1520)); + callArgs_164[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_164); + long[] callArgs_165 = new long[1]; + callArgs_165[0] = ((long) 36); + long[] callResult_165 = instance.getMachine().call(1776, callArgs_165); + iL[0] = ((int) callResult_165[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 35); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 55796); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + int ciTableIdx_166 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_166 = instance.table(0).requiredRef(ciTableIdx_166); + com.dylibso.chicory.runtime.Instance ciRefInstance_166 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_166), instance); + if (!ciRefInstance_166.type(ciRefInstance_166.functionType(ciFuncId_166)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_166 = new long[1]; + callArgs_166[0] = ((long) iL[3]); + ciRefInstance_166.getMachine().call(ciFuncId_166, callArgs_166); + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_167 = new long[2]; + callArgs_167[1] = ((long) (iL[2] + 1520)); + callArgs_167[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_167); + memory.writeLong((int) ((iL[2] + 536) + 8) < 0 ? ((iL[2] + 536) + 8) : ((iL[2] + 536) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) ((iL[2] + 536) + 16) < 0 ? ((iL[2] + 536) + 16) : ((iL[2] + 536) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 536, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_168 = new long[3]; + callArgs_168[2] = ((long) iL[1]); + callArgs_168[1] = ((long) (iL[2] + 536)); + callArgs_168[0] = ((long) iL[0]); + long[] callResult_168 = instance.getMachine().call(1286, callArgs_168); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_168[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + { + _hs[0] = 10001; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_169 = new long[2]; + callArgs_169[1] = ((long) (iL[2] + 1520)); + callArgs_169[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_169); + long[] callArgs_170 = new long[1]; + callArgs_170[0] = ((long) 36); + long[] callResult_170 = instance.getMachine().call(1776, callArgs_170); + iL[0] = ((int) callResult_170[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 60); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 55976); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + int ciTableIdx_171 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_171 = instance.table(0).requiredRef(ciTableIdx_171); + com.dylibso.chicory.runtime.Instance ciRefInstance_171 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_171), instance); + if (!ciRefInstance_171.type(ciRefInstance_171.functionType(ciFuncId_171)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_171 = new long[1]; + callArgs_171[0] = ((long) iL[3]); + ciRefInstance_171.getMachine().call(ciFuncId_171, callArgs_171); + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_172 = new long[2]; + callArgs_172[1] = ((long) (iL[2] + 1520)); + callArgs_172[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_172); + memory.writeLong((int) ((iL[2] + 560) + 8) < 0 ? ((iL[2] + 560) + 8) : ((iL[2] + 560) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) ((iL[2] + 560) + 16) < 0 ? ((iL[2] + 560) + 16) : ((iL[2] + 560) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 560, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_173 = new long[3]; + callArgs_173[2] = ((long) iL[1]); + callArgs_173[1] = ((long) (iL[2] + 560)); + callArgs_173[0] = ((long) iL[0]); + long[] callResult_173 = instance.getMachine().call(1287, callArgs_173); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_173[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + { + _hs[0] = 10001; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + iL[4] = ((iL[2] + 1520) + 32); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + iL[6] = ((iL[2] + 1520) + 24); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + iL[7] = ((iL[2] + 1520) + 16); + memory.writeLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + iL[8] = ((iL[2] + 1520) + 8); + memory.writeLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_174 = new long[2]; + callArgs_174[1] = ((long) (iL[2] + 1520)); + callArgs_174[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_174); + memory.writeI32((int) ((iL[2] + 624) + 16) < 0 ? ((iL[2] + 624) + 16) : ((iL[2] + 624) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 624) + 8) < 0 ? ((iL[2] + 624) + 8) : ((iL[2] + 624) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) ((iL[2] + 584) + 8) < 0 ? ((iL[2] + 584) + 8) : ((iL[2] + 584) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + memory.writeLong((int) ((iL[2] + 584) + 16) < 0 ? ((iL[2] + 584) + 16) : ((iL[2] + 584) + 16) + 0, (long) memory.readLong((int) iL[7] < 0 ? iL[7] : iL[7] + 0)); + memory.writeLong((int) ((iL[2] + 584) + 24) < 0 ? ((iL[2] + 584) + 24) : ((iL[2] + 584) + 24) + 0, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + memory.writeI32((int) ((iL[2] + 584) + 32) < 0 ? ((iL[2] + 584) + 32) : ((iL[2] + 584) + 32) + 0, (int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 624, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 584, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520)); + long[] callArgs_175 = new long[4]; + callArgs_175[3] = ((long) iL[1]); + callArgs_175[2] = ((long) (iL[2] + 584)); + callArgs_175[1] = ((long) (iL[2] + 624)); + callArgs_175[0] = ((long) iL[0]); + long[] callResult_175 = instance.getMachine().call(1288, callArgs_175); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_175[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + { + _hs[0] = 10001; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_51__h3(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_50: { + label_51: { + label_52: { + label_53: { + label_54: { + label_55: { + label_56: { + label_57: { + int _d4 = func_51__h4(iL, lL, memory, instance); + if (_d4 == 1) + break label_56; + if (_d4 == 2) + break label_55; + if (_d4 == 3) + break label_54; + if (_d4 == 4) + break label_52; + if (_d4 == 5) + break label_51; + if (_d4 == 6) + break label_53; + if (_d4 == 7) + break label_50; + if (_d4 >= 10000) { + _hs[0] = (_d4 - 10000); + break _hb; + } + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) 12); + callArgs_13[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_13); + long[] callArgs_14 = new long[3]; + callArgs_14[2] = ((long) 14136); + callArgs_14[1] = ((long) memory.readInt((int) (iL[2] + 60) < 0 ? (iL[2] + 60) : (iL[2] + 60) + 0)); + callArgs_14[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_14); + { + _hs[0] = 20023; + break _hb; + } + } + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) 13); + callArgs_15[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_15); + long[] callArgs_16 = new long[3]; + callArgs_16[2] = ((long) 14136); + callArgs_16[1] = ((long) memory.readInt((int) (iL[2] + 60) < 0 ? (iL[2] + 60) : (iL[2] + 60) + 0)); + callArgs_16[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_16); + { + _hs[0] = 20023; + break _hb; + } + } + long[] callArgs_17 = new long[2]; + callArgs_17[1] = ((long) 14); + callArgs_17[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_17); + iL[4] = (iL[2] + 40); + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) 7754); + callArgs_18[1] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) - memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)), 36)); + callArgs_18[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_18); + label_67: { + iL[1] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36); + iL[4] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[4], iL[1]) != 0) { + break label_67; + } + label_68: while (true) { + long[] callArgs_19 = new long[3]; + callArgs_19[2] = ((long) 14136); + callArgs_19[1] = ((long) memory.readInt((int) (iL[1] + 24) < 0 ? (iL[1] + 24) : (iL[1] + 24) + 0)); + callArgs_19[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_19); + iL[1] = (iL[1] + 36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[4], iL[1]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_68; + } + break; + } + } + long[] callArgs_20 = new long[3]; + callArgs_20[2] = ((long) 7089); + callArgs_20[1] = ((long) memory.readInt((int) (iL[2] + 72) < 0 ? (iL[2] + 72) : (iL[2] + 72) + 0)); + callArgs_20[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_20); + { + _hs[0] = 20023; + break _hb; + } + } + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) (iL[2] + 36)); + callArgs_21[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_21 = instance.getMachine().call(121, callArgs_21); + iL[2] = ((int) callResult_21[0]); + long[] callArgs_22 = new long[2]; + callArgs_22[1] = ((long) 16); + callArgs_22[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_22); + long[] callArgs_23 = new long[4]; + callArgs_23[3] = ((long) 0); + callArgs_23[2] = ((long) 1564); + callArgs_23[1] = ((long) iL[2]); + callArgs_23[0] = ((long) iL[0]); + instance.getMachine().call(63, callArgs_23); + { + _hs[0] = 20023; + break _hb; + } + } + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) (iL[2] + 36)); + callArgs_24[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_24 = instance.getMachine().call(121, callArgs_24); + iL[2] = ((int) callResult_24[0]); + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) 18); + callArgs_25[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_25); + long[] callArgs_26 = new long[4]; + callArgs_26[3] = ((long) 0); + callArgs_26[2] = ((long) 1564); + callArgs_26[1] = ((long) iL[2]); + callArgs_26[0] = ((long) iL[0]); + instance.getMachine().call(63, callArgs_26); + { + _hs[0] = 20023; + break _hb; + } + } + long[] callArgs_27 = new long[2]; + callArgs_27[1] = ((long) (iL[2] + 36)); + callArgs_27[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_27 = instance.getMachine().call(135, callArgs_27); + iL[1] = ((int) callResult_27[0]); + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) (iL[2] + 140)); + callArgs_28[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_28 = instance.getMachine().call(123, callArgs_28); + iL[2] = ((int) callResult_28[0]); + long[] callArgs_29 = new long[2]; + callArgs_29[1] = ((long) 17); + callArgs_29[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_29); + long[] callArgs_30 = new long[4]; + callArgs_30[3] = ((long) 6); + callArgs_30[2] = ((long) 1903); + callArgs_30[1] = ((long) iL[1]); + callArgs_30[0] = ((long) iL[0]); + instance.getMachine().call(63, callArgs_30); + long[] callArgs_31 = new long[3]; + callArgs_31[2] = ((long) 2118); + callArgs_31[1] = ((long) iL[2]); + callArgs_31[0] = ((long) iL[0]); + instance.getMachine().call(64, callArgs_31); + { + _hs[0] = 20023; + break _hb; + } + } + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) 20); + callArgs_32[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_32); + { + _hs[0] = 20023; + break _hb; + } + } + long[] callArgs_33 = new long[2]; + callArgs_33[1] = ((long) (iL[2] + 36)); + callArgs_33[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_33 = instance.getMachine().call(135, callArgs_33); + iL[1] = ((int) callResult_33[0]); + long[] callArgs_34 = new long[2]; + callArgs_34[1] = ((long) (iL[2] + 140)); + callArgs_34[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_34 = instance.getMachine().call(123, callArgs_34); + iL[2] = ((int) callResult_34[0]); + long[] callArgs_35 = new long[2]; + callArgs_35[1] = ((long) 19); + callArgs_35[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_35); + long[] callArgs_36 = new long[4]; + callArgs_36[3] = ((long) 6); + callArgs_36[2] = ((long) 1903); + callArgs_36[1] = ((long) iL[1]); + callArgs_36[0] = ((long) iL[0]); + instance.getMachine().call(63, callArgs_36); + long[] callArgs_37 = new long[3]; + callArgs_37[2] = ((long) 2118); + callArgs_37[1] = ((long) iL[2]); + callArgs_37[0] = ((long) iL[0]); + instance.getMachine().call(64, callArgs_37); + { + _hs[0] = 20023; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_194__h1_helper0(int _sel, int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + switch(_sel) { + case 0: + { + break _hb; + } + case 1: + { + break _hb; + } + case 2: + { + break _hb; + } + case 3: + { + break _hb; + } + case 4: + { + break _hb; + } + case 5: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 6: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 7: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 8: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 9: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 10: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 11: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 12: + { + { + _hs[0] = 1; + break _hb; + } + } + case 13: + { + { + _hs[0] = 1; + break _hb; + } + } + case 14: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 15: + { + break _hb; + } + case 16: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 17: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 18: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 19: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 20: + { + break _hb; + } + case 21: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 22: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 23: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 24: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 25: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 26: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 27: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 28: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 29: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 30: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 31: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 32: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 33: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 34: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 35: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 36: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 37: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 38: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 39: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 40: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 41: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 42: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 43: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 44: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 45: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 46: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 47: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 48: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 49: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 50: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 51: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 52: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 53: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 54: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 55: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 56: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 57: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 58: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 59: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 60: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 61: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 62: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 63: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 64: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 65: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 66: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 67: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 68: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 69: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 70: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 71: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 72: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 73: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 74: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 75: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 76: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 77: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 78: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 79: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 80: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 81: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 82: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 83: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 84: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 85: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 86: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 87: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 88: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 89: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 90: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 91: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 92: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 93: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 94: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 95: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 96: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 97: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 98: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 99: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 100: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 101: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 102: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 103: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 104: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 105: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 106: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 107: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 108: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 109: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 110: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 111: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 112: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 113: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 114: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 115: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 116: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 117: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 118: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 119: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 120: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 121: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 122: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 123: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 124: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 125: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 126: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 127: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 128: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 129: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 130: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 131: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 132: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 133: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 134: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 135: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 136: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 137: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 138: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 139: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 140: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 141: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 142: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 143: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 144: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 145: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 146: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 147: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 148: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 149: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 150: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 151: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 152: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 153: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 154: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 155: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 156: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 157: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 158: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 159: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 160: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 161: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 162: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 163: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 164: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 165: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 166: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 167: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 168: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 169: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 170: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 171: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 172: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 173: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 174: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 175: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 176: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 177: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 178: + { + { + _hs[0] = 2; + break _hb; + } + } + case 179: + { + { + _hs[0] = 2; + break _hb; + } + } + case 180: + { + { + _hs[0] = 2; + break _hb; + } + } + case 181: + { + { + _hs[0] = 2; + break _hb; + } + } + case 182: + { + { + _hs[0] = 2; + break _hb; + } + } + case 183: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 184: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 185: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 186: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 187: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 188: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 189: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 190: + { + { + _hs[0] = 3; + break _hb; + } + } + case 191: + { + { + _hs[0] = 3; + break _hb; + } + } + case 192: + { + { + _hs[0] = 3; + break _hb; + } + } + case 193: + { + { + _hs[0] = 3; + break _hb; + } + } + case 194: + { + { + _hs[0] = 3; + break _hb; + } + } + case 195: + { + { + _hs[0] = 3; + break _hb; + } + } + case 196: + { + { + _hs[0] = 3; + break _hb; + } + } + case 197: + { + { + _hs[0] = 3; + break _hb; + } + } + case 198: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 199: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 200: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 201: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 202: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 203: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 204: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 205: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 206: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 207: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 208: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 209: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 210: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 211: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 212: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 213: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 214: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 215: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 216: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 217: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 218: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 219: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 220: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 221: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 222: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 223: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 224: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 225: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 226: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 227: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 228: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 229: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 230: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 231: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 232: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 233: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 234: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 235: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 236: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 237: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 238: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 239: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 240: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 241: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 242: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 243: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 244: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 245: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 246: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 247: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 248: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 249: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 250: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 251: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 252: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 253: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 254: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 255: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 256: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 257: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 258: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 259: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 260: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 261: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 262: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 263: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 264: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 265: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 266: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 267: + { + { + _hs[0] = 10006; + break _hb; + } + } + } + } while (false); + return _hs[0]; + } + + private static int func_194__h1_helper1(int _sel, int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + switch(_sel) { + case 268: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 269: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 270: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 271: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 272: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 273: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 274: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 275: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 276: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 277: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 278: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 279: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 280: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 281: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 282: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 283: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 284: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 285: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 286: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 287: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 288: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 289: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 290: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 291: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 292: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 293: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 294: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 295: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 296: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 297: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 298: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 299: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 300: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 301: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 302: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 303: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 304: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 305: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 306: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 307: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 308: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 309: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 310: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 311: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 312: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 313: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 314: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 315: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 316: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 317: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 318: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 319: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 320: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 321: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 322: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 323: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 324: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 325: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 326: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 327: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 328: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 329: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 330: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 331: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 332: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 333: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 334: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 335: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 336: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 337: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 338: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 339: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 340: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 341: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 342: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 343: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 344: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 345: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 346: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 347: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 348: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 349: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 350: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 351: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 352: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 353: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 354: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 355: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 356: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 357: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 358: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 359: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 360: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 361: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 362: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 363: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 364: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 365: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 366: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 367: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 368: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 369: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 370: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 371: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 372: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 373: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 374: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 375: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 376: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 377: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 378: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 379: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 380: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 381: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 382: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 383: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 384: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 385: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 386: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 387: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 388: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 389: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 390: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 391: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 392: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 393: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 394: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 395: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 396: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 397: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 398: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 399: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 400: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 401: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 402: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 403: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 404: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 405: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 406: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 407: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 408: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 409: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 410: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 411: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 412: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 413: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 414: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 415: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 416: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 417: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 418: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 419: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 420: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 421: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 422: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 423: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 424: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 425: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 426: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 427: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 428: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 429: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 430: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 431: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 432: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 433: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 434: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 435: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 436: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 437: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 438: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 439: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 440: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 441: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 442: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 443: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 444: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 445: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 446: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 447: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 448: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 449: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 450: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 451: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 452: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 453: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 454: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 455: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 456: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 457: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 458: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 459: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 460: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 461: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 462: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 463: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 464: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 465: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 466: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 467: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 468: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 469: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 470: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 471: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 472: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 473: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 474: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 475: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 476: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 477: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 478: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 479: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 480: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 481: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 482: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 483: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 484: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 485: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 486: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 487: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 488: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 489: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 490: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 491: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 492: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 493: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 494: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 495: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 496: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 497: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 498: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 499: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 500: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 501: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 502: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 503: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 504: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 505: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 506: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 507: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 508: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 509: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 510: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 511: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 512: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 513: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 514: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 515: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 516: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 517: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 518: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 519: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 520: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 521: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 522: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 523: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 524: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 525: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 526: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 527: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 528: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 529: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 530: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 531: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 532: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 533: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 534: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 535: + { + { + _hs[0] = 10000; + break _hb; + } + } + default: + { + { + _hs[0] = 10001; + break _hb; + } + } + } + } while (false); + return _hs[0]; + } + + private static int func_450__h3(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_54: { + label_55: { + label_56: { + label_57: { + label_58: { + label_59: { + label_60: { + int _d4 = func_450__h4(iL, memory, instance); + if (_d4 == 1) + break label_59; + if (_d4 == 2) + break label_58; + if (_d4 == 3) + break label_57; + if (_d4 == 4) + break label_56; + if (_d4 == 5) + break label_55; + if (_d4 == 6) + break label_54; + if (_d4 >= 10000) { + _hs[0] = (_d4 - 10000); + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_7 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 8)); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) iL[1]); + callArgs_7[0] = ((long) iL[0]); + long[] callResult_7 = ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_7[0])) != 0) { + { + _hs[0] = 20024; + break _hb; + } + } + { + _hs[0] = 20025; + break _hb; + } + } + iL[2] = 1; + iL[3] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_8 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 12)); + int ciFuncId_8 = instance.table(0).requiredRef(ciTableIdx_8); + com.dylibso.chicory.runtime.Instance ciRefInstance_8 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_8), instance); + if (!ciRefInstance_8.type(ciRefInstance_8.functionType(ciFuncId_8)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) iL[1]); + callArgs_8[0] = ((long) iL[3]); + long[] callResult_8 = ciRefInstance_8.getMachine().call(ciFuncId_8, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_8[0])) != 0) { + { + _hs[0] = 20025; + break _hb; + } + } + long[] callArgs_9 = new long[4]; + callArgs_9[3] = ((long) (iL[1] + 152)); + callArgs_9[2] = ((long) iL[1]); + callArgs_9[1] = ((long) 1); + callArgs_9[0] = ((long) iL[0]); + instance.getMachine().call(451, callArgs_9); + { + _hs[0] = 20024; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_10 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 20)); + int ciFuncId_10 = instance.table(0).requiredRef(ciTableIdx_10); + com.dylibso.chicory.runtime.Instance ciRefInstance_10 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_10), instance); + if (!ciRefInstance_10.type(ciRefInstance_10.functionType(ciFuncId_10)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) iL[1]); + callArgs_10[0] = ((long) iL[0]); + long[] callResult_10 = ciRefInstance_10.getMachine().call(ciFuncId_10, callArgs_10); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_10[0])) != 0) { + { + _hs[0] = 20024; + break _hb; + } + } + { + _hs[0] = 20025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_11 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 24)); + int ciFuncId_11 = instance.table(0).requiredRef(ciTableIdx_11); + com.dylibso.chicory.runtime.Instance ciRefInstance_11 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_11), instance); + if (!ciRefInstance_11.type(ciRefInstance_11.functionType(ciFuncId_11)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) iL[1]); + callArgs_11[0] = ((long) iL[0]); + long[] callResult_11 = ciRefInstance_11.getMachine().call(ciFuncId_11, callArgs_11); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_11[0])) != 0) { + { + _hs[0] = 20024; + break _hb; + } + } + { + _hs[0] = 20025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_12 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 28)); + int ciFuncId_12 = instance.table(0).requiredRef(ciTableIdx_12); + com.dylibso.chicory.runtime.Instance ciRefInstance_12 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_12), instance); + if (!ciRefInstance_12.type(ciRefInstance_12.functionType(ciFuncId_12)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) iL[1]); + callArgs_12[0] = ((long) iL[0]); + long[] callResult_12 = ciRefInstance_12.getMachine().call(ciFuncId_12, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_12[0])) != 0) { + { + _hs[0] = 20024; + break _hb; + } + } + { + _hs[0] = 20025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_13 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 40)); + int ciFuncId_13 = instance.table(0).requiredRef(ciTableIdx_13); + com.dylibso.chicory.runtime.Instance ciRefInstance_13 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_13), instance); + if (!ciRefInstance_13.type(ciRefInstance_13.functionType(ciFuncId_13)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) iL[1]); + callArgs_13[0] = ((long) iL[0]); + long[] callResult_13 = ciRefInstance_13.getMachine().call(ciFuncId_13, callArgs_13); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_13[0])) != 0) { + { + _hs[0] = 20024; + break _hb; + } + } + { + _hs[0] = 20025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_14 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 44)); + int ciFuncId_14 = instance.table(0).requiredRef(ciTableIdx_14); + com.dylibso.chicory.runtime.Instance ciRefInstance_14 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_14), instance); + if (!ciRefInstance_14.type(ciRefInstance_14.functionType(ciFuncId_14)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) iL[1]); + callArgs_14[0] = ((long) iL[0]); + long[] callResult_14 = ciRefInstance_14.getMachine().call(ciFuncId_14, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_14[0])) != 0) { + { + _hs[0] = 20024; + break _hb; + } + } + { + _hs[0] = 20025; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_557__h2(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_23: { + label_24: { + label_25: { + iL[8] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + switch((iL[8] + -9)) { + case 0: + { + break _hb; + } + case 1: + { + break _hb; + } + case 2: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 3: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 4: + { + break _hb; + } + case 5: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 6: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 7: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 8: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 9: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 10: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 11: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 12: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 13: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 14: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 15: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 16: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 17: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 18: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 19: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 20: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 21: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 22: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 23: + { + break _hb; + } + case 24: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 25: + { + { + _hs[0] = 1; + break _hb; + } + } + case 26: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 27: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 28: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 29: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 30: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 31: + { + break label_25; + } + case 32: + { + break label_24; + } + case 33: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 34: + { + { + _hs[0] = 2; + break _hb; + } + } + case 35: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 36: + { + { + _hs[0] = 2; + break _hb; + } + } + case 37: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 38: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 39: + { + { + _hs[0] = 3; + break _hb; + } + } + case 40: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 41: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 42: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 43: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 44: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 45: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 46: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 47: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 48: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 49: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 50: + { + break label_23; + } + case 51: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 52: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 53: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 54: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 55: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 56: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 57: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 58: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 59: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 60: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 61: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 62: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 63: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 64: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 65: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 66: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 67: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 68: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 69: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 70: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 71: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 72: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 73: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 74: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 75: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 76: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 77: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 78: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 79: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 80: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 81: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 82: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 83: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 84: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 85: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 86: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 87: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 88: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 89: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 90: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 91: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 92: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 93: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 94: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 95: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 96: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 97: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 98: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 99: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 100: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 101: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 102: + { + { + _hs[0] = 10006; + break _hb; + } + } + default: + { + { + _hs[0] = 10001; + break _hb; + } + } + } + } + iL[9] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[4], iL[5]); + if (iL[9] != 0) { + { + _hs[0] = 20001; + break _hb; + } + } + { + _hs[0] = 20002; + break _hb; + } + } + iL[5] = (iL[4] + 1); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 36, (int) iL[5]); + iL[8] = ((iL[3] + 288) + 8); + memory.writeI32((int) iL[8] < 0 ? iL[8] : iL[8] + 0, (int) memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 16)); + iL[7] = memory.readInt((int) (iL[1] + 28) < 0 ? (iL[1] + 28) : (iL[1] + 28) + 0); + iL[4] = (iL[4] - iL[7]); + memory.writeI32((int) (iL[3] + 300) < 0 ? (iL[3] + 300) : (iL[3] + 300) + 0, (int) ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1)); + iL[4] = (iL[5] - iL[7]); + iL[5] = ((com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[4], 0) != 0 ? iL[4] : 0) + 1); + memory.writeI32((int) ((iL[3] + 288) + 16) < 0 ? ((iL[3] + 288) + 16) : ((iL[3] + 288) + 16) + 0, (int) iL[5]); + iL[7] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 4); + iL[9] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 8); + iL[4] = ((int) memory.read((int) iL[1] < 0 ? iL[1] : iL[1] + 15) & 0xFF); + memory.writeI32((int) ((iL[3] + 144) + 16) < 0 ? ((iL[3] + 144) + 16) : ((iL[3] + 144) + 16) + 0, (int) iL[5]); + memory.writeLong((int) ((iL[3] + 144) + 8) < 0 ? ((iL[3] + 144) + 8) : ((iL[3] + 144) + 8) + 0, (long) memory.readLong((int) iL[8] < 0 ? iL[8] : iL[8] + 0)); + iL[1] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[4]), 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 292, (int) (iL[1] != 0 ? iL[9] : iL[4])); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 288, (int) (iL[1] != 0 ? iL[7] : iL[6])); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 144, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 288)); + long[] callArgs_0 = new long[3]; + callArgs_0[2] = ((long) 44); + callArgs_0[1] = ((long) (iL[3] + 144)); + callArgs_0[0] = ((long) iL[0]); + long[] callResult_0 = instance.getMachine().call(539, callArgs_0); + { + _hs[0] = 20003; + break _hb; + } + } + iL[9] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[4], iL[5]); + if (iL[9] != 0) { + { + _hs[0] = 20004; + break _hb; + } + } + { + _hs[0] = 20005; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h5(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_54: { + int _d13 = func_801__h13(iL, lL, memory, instance); + if (_d13 >= 10000) { + _hs[0] = (_d13 - 10000); + break _hb; + } + } + label_167: { + label_168: { + label_169: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_170 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 624)); + int ciFuncId_170 = instance.table(0).requiredRef(ciTableIdx_170); + com.dylibso.chicory.runtime.Instance ciRefInstance_170 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_170), instance); + if (!ciRefInstance_170.type(ciRefInstance_170.functionType(ciFuncId_170)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_170 = new long[2]; + callArgs_170[1] = ((long) iL[0]); + callArgs_170[0] = ((long) iL[3]); + long[] callResult_170 = ciRefInstance_170.getMachine().call(ciFuncId_170, callArgs_170); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_170[0])) != 0) { + break label_169; + } + long[] callArgs_171 = new long[3]; + callArgs_171[2] = ((long) 0); + callArgs_171[1] = ((long) 24651); + callArgs_171[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_171); + break label_168; + } + label_170: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_172 = new long[3]; + callArgs_172[2] = ((long) (iL[4] + 3168)); + callArgs_172[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_172[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_172 = instance.getMachine().call(177, callArgs_172); + iL[0] = ((int) callResult_172[0]); + if (iL[0] != 0) { + break label_170; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2640, (int) 6257); + long[] callArgs_173 = new long[3]; + callArgs_173[2] = ((long) (iL[4] + 2640)); + callArgs_173[1] = ((long) 11260); + callArgs_173[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_173); + break label_168; + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3076, (int) iL[3]); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_171: { + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_171; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2664, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2660, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2656, (int) 6257); + long[] callArgs_174 = new long[3]; + callArgs_174[2] = ((long) (iL[4] + 2656)); + callArgs_174[1] = ((long) 12552); + callArgs_174[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_174); + break label_168; + } + label_172: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_175 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 628)); + int ciFuncId_175 = instance.table(0).requiredRef(ciTableIdx_175); + com.dylibso.chicory.runtime.Instance ciRefInstance_175 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_175), instance); + if (!ciRefInstance_175.type(ciRefInstance_175.functionType(ciFuncId_175)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_175 = new long[2]; + callArgs_175[1] = ((long) iL[3]); + callArgs_175[0] = ((long) iL[0]); + long[] callResult_175 = ciRefInstance_175.getMachine().call(ciFuncId_175, callArgs_175); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_175[0])) != 0) { + break label_172; + } + long[] callArgs_176 = new long[3]; + callArgs_176[2] = ((long) 0); + callArgs_176[1] = ((long) 19456); + callArgs_176[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_176); + break label_168; + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3076); + label_173: { + label_174: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3080); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[0]) != 0) { + break label_174; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[3], iL[0]) != 0) { + break label_173; + } + } + label_175: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_175; + } + iL[3] = 0; + label_176: while (true) { + label_177: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_177 = new long[3]; + callArgs_177[2] = ((long) (iL[4] + 3256)); + callArgs_177[1] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_177[0] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_177 = instance.getMachine().call(177, callArgs_177); + iL[0] = ((int) callResult_177[0]); + if (iL[0] != 0) { + break label_177; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2672, (int) 8267); + long[] callArgs_178 = new long[3]; + callArgs_178[2] = ((long) (iL[4] + 2672)); + callArgs_178[1] = ((long) 11260); + callArgs_178[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_178); + break label_168; + } + iL[14] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[14]); + iL[13] = 0; + label_178: { + label_179: { + label_180: { + label_181: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + if (iL[0] != 0) { + break label_181; + } + iL[0] = 0; + break label_180; + } + label_182: { + if (((int) memory.read((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) + 9) & 0xFF) != 0) { + break label_182; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2720, (int) iL[0]); + long[] callArgs_179 = new long[3]; + callArgs_179[2] = ((long) (iL[4] + 2720)); + callArgs_179[1] = ((long) 17948); + callArgs_179[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_179); + break label_168; + } + label_183: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 8) != 0) { + break label_183; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2736, (int) iL[0]); + long[] callArgs_180 = new long[3]; + callArgs_180[2] = ((long) (iL[4] + 2736)); + callArgs_180[1] = ((long) 2664); + callArgs_180[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_180); + break label_168; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[0] & 2)) != 0) { + break label_180; + } + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_181 = new long[3]; + callArgs_181[2] = ((long) (iL[4] + 3168)); + callArgs_181[1] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_181[0] = ((long) (iL[0] + iL[14])); + long[] callResult_181 = instance.getMachine().call(177, callArgs_181); + iL[0] = ((int) callResult_181[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_179; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + } + label_184: { + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_182 = (int) (memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 632)); + int ciFuncId_182 = instance.table(0).requiredRef(ciTableIdx_182); + com.dylibso.chicory.runtime.Instance ciRefInstance_182 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_182), instance); + if (!ciRefInstance_182.type(ciRefInstance_182.functionType(ciFuncId_182)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_182 = new long[4]; + callArgs_182[3] = ((long) (iL[0] & 255)); + callArgs_182[2] = ((long) iL[13]); + callArgs_182[1] = ((long) iL[3]); + callArgs_182[0] = ((long) iL[14]); + long[] callResult_182 = ciRefInstance_182.getMachine().call(ciFuncId_182, callArgs_182); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_182[0])) != 0) { + break label_184; + } + long[] callArgs_183 = new long[3]; + callArgs_183[2] = ((long) 0); + callArgs_183[1] = ((long) 20252); + callArgs_183[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_183); + break label_168; + } + label_185: { + if ((((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 3256) & 0xFF) & 1) != 0) { + break label_185; + } + label_186: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_184 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 636)); + int ciFuncId_184 = instance.table(0).requiredRef(ciTableIdx_184); + com.dylibso.chicory.runtime.Instance ciRefInstance_184 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_184), instance); + if (!ciRefInstance_184.type(ciRefInstance_184.functionType(ciFuncId_184)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_184 = new long[2]; + callArgs_184[1] = ((long) iL[3]); + callArgs_184[0] = ((long) iL[0]); + long[] callResult_184 = ciRefInstance_184.getMachine().call(ciFuncId_184, callArgs_184); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_184[0])) != 0) { + break label_186; + } + long[] callArgs_185 = new long[3]; + callArgs_185[2] = ((long) 0); + callArgs_185[1] = ((long) 21013); + callArgs_185[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_185); + break label_168; + } + long[] callArgs_186 = new long[3]; + callArgs_186[2] = ((long) 12729); + callArgs_186[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)); + callArgs_186[0] = ((long) (iL[4] + 2936)); + long[] callResult_186 = instance.getMachine().call(804, callArgs_186); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_186[0])) != 0) { + break label_168; + } + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_187 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 640)); + int ciFuncId_187 = instance.table(0).requiredRef(ciTableIdx_187); + com.dylibso.chicory.runtime.Instance ciRefInstance_187 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_187), instance); + if (!ciRefInstance_187.type(ciRefInstance_187.functionType(ciFuncId_187)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_187 = new long[2]; + callArgs_187[1] = ((long) iL[3]); + callArgs_187[0] = ((long) iL[0]); + long[] callResult_187 = ciRefInstance_187.getMachine().call(ciFuncId_187, callArgs_187); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_187[0])) != 0) { + break label_185; + } + long[] callArgs_188 = new long[3]; + callArgs_188[2] = ((long) 0); + callArgs_188[1] = ((long) 21054); + callArgs_188[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_188); + break label_168; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (int) 0); + label_187: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_189 = new long[3]; + callArgs_189[2] = ((long) (iL[4] + 3168)); + callArgs_189[1] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_189[0] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_189 = instance.getMachine().call(177, callArgs_189); + iL[0] = ((int) callResult_189[0]); + if (iL[0] != 0) { + break label_187; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2688, (int) 15187); + long[] callArgs_190 = new long[3]; + callArgs_190[2] = ((long) (iL[4] + 2688)); + callArgs_190[1] = ((long) 11260); + callArgs_190[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_190); + break label_168; + } + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_188: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[14] = (iL[13] + iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[14], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)) != 0) { + break label_188; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2704, (int) 26717); + long[] callArgs_191 = new long[3]; + callArgs_191[2] = ((long) (iL[4] + 2704)); + callArgs_191[1] = ((long) 11176); + callArgs_191[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_191); + break label_168; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[14]); + label_189: { + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_192 = (int) (memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 644)); + int ciFuncId_192 = instance.table(0).requiredRef(ciTableIdx_192); + com.dylibso.chicory.runtime.Instance ciRefInstance_192 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_192), instance); + if (!ciRefInstance_192.type(ciRefInstance_192.functionType(ciFuncId_192)).typesMatch(instance.type(12))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_192 = new long[4]; + callArgs_192[3] = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(iL[13]); + callArgs_192[2] = ((long) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[0])); + callArgs_192[1] = ((long) iL[3]); + callArgs_192[0] = ((long) iL[14]); + long[] callResult_192 = ciRefInstance_192.getMachine().call(ciFuncId_192, callArgs_192); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_192[0])) != 0) { + break label_189; + } + long[] callArgs_193 = new long[3]; + callArgs_193[2] = ((long) 0); + callArgs_193[1] = ((long) 25670); + callArgs_193[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_193); + break label_168; + } + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_194 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 648)); + int ciFuncId_194 = instance.table(0).requiredRef(ciTableIdx_194); + com.dylibso.chicory.runtime.Instance ciRefInstance_194 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_194), instance); + if (!ciRefInstance_194.type(ciRefInstance_194.functionType(ciFuncId_194)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_194 = new long[2]; + callArgs_194[1] = ((long) iL[3]); + callArgs_194[0] = ((long) iL[0]); + long[] callResult_194 = ciRefInstance_194.getMachine().call(ciFuncId_194, callArgs_194); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_194[0])) != 0) { + break label_178; + } + long[] callArgs_195 = new long[3]; + callArgs_195[2] = ((long) 0); + callArgs_195[1] = ((long) 20285); + callArgs_195[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_195); + break label_168; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2752, (int) 1425); + long[] callArgs_196 = new long[3]; + callArgs_196[2] = ((long) (iL[4] + 2752)); + callArgs_196[1] = ((long) 11260); + callArgs_196[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_196); + break label_168; + } + iL[3] = (iL[3] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3076)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_176; + } + break; + } + } + label_190: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_197 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 652)); + int ciFuncId_197 = instance.table(0).requiredRef(ciTableIdx_197); + com.dylibso.chicory.runtime.Instance ciRefInstance_197 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_197), instance); + if (!ciRefInstance_197.type(ciRefInstance_197.functionType(ciFuncId_197)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_197 = new long[1]; + callArgs_197[0] = ((long) iL[3]); + long[] callResult_197 = ciRefInstance_197.getMachine().call(ciFuncId_197, callArgs_197); + if (((int) callResult_197[0]) != 0) { + break label_190; + } + iL[3] = 0; + break label_167; + } + long[] callArgs_198 = new long[3]; + callArgs_198[2] = ((long) 0); + callArgs_198[1] = ((long) 24684); + callArgs_198[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_198); + break label_168; + } + long[] callArgs_199 = new long[3]; + callArgs_199[2] = ((long) 0); + callArgs_199[1] = ((long) 12491); + callArgs_199[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_199); + } + iL[3] = 1; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 20009; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h5(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_112: { + label_113: { + label_114: { + label_115: { + label_116: { + int _d11 = func_804__h11(iL, lL, memory, instance); + if (_d11 == 1) + break label_113; + if (_d11 == 2) + break label_112; + if (_d11 == 3) + break label_114; + if (_d11 == 4) + break label_115; + if (_d11 >= 10000) { + _hs[0] = (_d11 - 10000); + break _hb; + } + } + iL[11] = 1; + long[] callArgs_91 = new long[3]; + callArgs_91[2] = ((long) 1663); + callArgs_91[1] = ((long) (iL[3] + 352)); + callArgs_91[0] = ((long) iL[0]); + long[] callResult_91 = instance.getMachine().call(814, callArgs_91); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_91[0])) != 0) { + { + _hs[0] = 20007; + break _hb; + } + } + label_172: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_92 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 408)); + int ciFuncId_92 = instance.table(0).requiredRef(ciTableIdx_92); + com.dylibso.chicory.runtime.Instance ciRefInstance_92 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_92), instance); + if (!ciRefInstance_92.type(ciRefInstance_92.functionType(ciFuncId_92)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_92 = new long[2]; + callArgs_92[1] = ((long) iL[12]); + callArgs_92[0] = ((long) iL[4]); + long[] callResult_92 = ciRefInstance_92.getMachine().call(ciFuncId_92, callArgs_92); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_92[0])) != 0) { + break label_172; + } + iL[4] = 21322; + { + _hs[0] = 20022; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_93 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_93 = instance.table(0).requiredRef(ciTableIdx_93); + com.dylibso.chicory.runtime.Instance ciRefInstance_93 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_93), instance); + if (!ciRefInstance_93.type(ciRefInstance_93.functionType(ciFuncId_93)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_93 = new long[2]; + callArgs_93[1] = ((long) iL[12]); + callArgs_93[0] = ((long) iL[4]); + long[] callResult_93 = ciRefInstance_93.getMachine().call(ciFuncId_93, callArgs_93); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_93[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 20022; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_94 = new long[3]; + callArgs_94[2] = ((long) 1727); + callArgs_94[1] = ((long) (iL[3] + 352)); + callArgs_94[0] = ((long) iL[0]); + long[] callResult_94 = instance.getMachine().call(814, callArgs_94); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_94[0])) != 0) { + { + _hs[0] = 20007; + break _hb; + } + } + label_173: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_95 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 388)); + int ciFuncId_95 = instance.table(0).requiredRef(ciTableIdx_95); + com.dylibso.chicory.runtime.Instance ciRefInstance_95 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_95), instance); + if (!ciRefInstance_95.type(ciRefInstance_95.functionType(ciFuncId_95)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_95 = new long[2]; + callArgs_95[1] = ((long) iL[12]); + callArgs_95[0] = ((long) iL[4]); + long[] callResult_95 = ciRefInstance_95.getMachine().call(ciFuncId_95, callArgs_95); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_95[0])) != 0) { + break label_173; + } + iL[4] = 21259; + { + _hs[0] = 20023; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_96 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_96 = instance.table(0).requiredRef(ciTableIdx_96); + com.dylibso.chicory.runtime.Instance ciRefInstance_96 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_96), instance); + if (!ciRefInstance_96.type(ciRefInstance_96.functionType(ciFuncId_96)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_96 = new long[2]; + callArgs_96[1] = ((long) iL[12]); + callArgs_96[0] = ((long) iL[4]); + long[] callResult_96 = ciRefInstance_96.getMachine().call(ciFuncId_96, callArgs_96); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_96[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 20023; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_97 = new long[3]; + callArgs_97[2] = ((long) 1641); + callArgs_97[1] = ((long) (iL[3] + 352)); + callArgs_97[0] = ((long) iL[0]); + long[] callResult_97 = instance.getMachine().call(814, callArgs_97); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_97[0])) != 0) { + { + _hs[0] = 20007; + break _hb; + } + } + label_174: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_98 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 412)); + int ciFuncId_98 = instance.table(0).requiredRef(ciTableIdx_98); + com.dylibso.chicory.runtime.Instance ciRefInstance_98 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_98), instance); + if (!ciRefInstance_98.type(ciRefInstance_98.functionType(ciFuncId_98)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_98 = new long[2]; + callArgs_98[1] = ((long) iL[12]); + callArgs_98[0] = ((long) iL[4]); + long[] callResult_98 = ciRefInstance_98.getMachine().call(ciFuncId_98, callArgs_98); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_98[0])) != 0) { + break label_174; + } + iL[4] = 21228; + { + _hs[0] = 20024; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_99 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_99 = instance.table(0).requiredRef(ciTableIdx_99); + com.dylibso.chicory.runtime.Instance ciRefInstance_99 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_99), instance); + if (!ciRefInstance_99.type(ciRefInstance_99.functionType(ciFuncId_99)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_99 = new long[2]; + callArgs_99[1] = ((long) iL[12]); + callArgs_99[0] = ((long) iL[4]); + long[] callResult_99 = ciRefInstance_99.getMachine().call(ciFuncId_99, callArgs_99); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_99[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 20024; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_100 = new long[3]; + callArgs_100[2] = ((long) 1533); + callArgs_100[1] = ((long) (iL[3] + 352)); + callArgs_100[0] = ((long) iL[0]); + long[] callResult_100 = instance.getMachine().call(814, callArgs_100); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_100[0])) != 0) { + { + _hs[0] = 20007; + break _hb; + } + } + label_175: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_101 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 328)); + int ciFuncId_101 = instance.table(0).requiredRef(ciTableIdx_101); + com.dylibso.chicory.runtime.Instance ciRefInstance_101 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_101), instance); + if (!ciRefInstance_101.type(ciRefInstance_101.functionType(ciFuncId_101)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_101 = new long[2]; + callArgs_101[1] = ((long) iL[12]); + callArgs_101[0] = ((long) iL[4]); + long[] callResult_101 = ciRefInstance_101.getMachine().call(ciFuncId_101, callArgs_101); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_101[0])) != 0) { + break label_175; + } + iL[4] = 22067; + { + _hs[0] = 20025; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_102 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_102 = instance.table(0).requiredRef(ciTableIdx_102); + com.dylibso.chicory.runtime.Instance ciRefInstance_102 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_102), instance); + if (!ciRefInstance_102.type(ciRefInstance_102.functionType(ciFuncId_102)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_102 = new long[2]; + callArgs_102[1] = ((long) iL[12]); + callArgs_102[0] = ((long) iL[4]); + long[] callResult_102 = ciRefInstance_102.getMachine().call(ciFuncId_102, callArgs_102); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_102[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 20025; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_103 = new long[3]; + callArgs_103[2] = ((long) 1815); + callArgs_103[1] = ((long) (iL[3] + 352)); + callArgs_103[0] = ((long) iL[0]); + long[] callResult_103 = instance.getMachine().call(814, callArgs_103); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_103[0])) != 0) { + { + _hs[0] = 20007; + break _hb; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 336, (int) 0); + label_176: { + label_177: { + label_178: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) < 0 ? memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) : memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) + 10) & 0xFF)) != 0) { + break label_178; + } + long[] callArgs_104 = new long[3]; + callArgs_104[2] = ((long) 2037); + callArgs_104[1] = ((long) (iL[3] + 336)); + callArgs_104[0] = ((long) iL[0]); + long[] callResult_104 = instance.getMachine().call(814, callArgs_104); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_104[0])) != 0) { + break label_176; + } + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + break label_177; + } + long[] callArgs_105 = new long[3]; + callArgs_105[2] = ((long) 18710); + callArgs_105[1] = ((long) (iL[3] + 348)); + callArgs_105[0] = ((long) iL[0]); + long[] callResult_105 = instance.getMachine().call(811, callArgs_105); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_105[0])) != 0) { + break label_176; + } + label_179: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 348) & 0xFF)) != 0) { + break label_179; + } + long[] callArgs_106 = new long[3]; + callArgs_106[2] = ((long) 0); + callArgs_106[1] = ((long) 28626); + callArgs_106[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_106); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[4] = 0; + } + label_180: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[11] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_107 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 332)); + int ciFuncId_107 = instance.table(0).requiredRef(ciTableIdx_107); + com.dylibso.chicory.runtime.Instance ciRefInstance_107 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_107), instance); + if (!ciRefInstance_107.type(ciRefInstance_107.functionType(ciFuncId_107)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_107 = new long[3]; + callArgs_107[2] = ((long) iL[4]); + callArgs_107[1] = ((long) iL[11]); + callArgs_107[0] = ((long) iL[12]); + long[] callResult_107 = ciRefInstance_107.getMachine().call(ciFuncId_107, callArgs_107); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_107[0])) != 0) { + break label_180; + } + long[] callArgs_108 = new long[3]; + callArgs_108[2] = ((long) 0); + callArgs_108[1] = ((long) 21457); + callArgs_108[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_108); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_109 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 244)); + int ciFuncId_109 = instance.table(0).requiredRef(ciTableIdx_109); + com.dylibso.chicory.runtime.Instance ciRefInstance_109 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_109), instance); + if (!ciRefInstance_109.type(ciRefInstance_109.functionType(ciFuncId_109)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_109 = new long[3]; + callArgs_109[2] = ((long) iL[4]); + callArgs_109[1] = ((long) iL[11]); + callArgs_109[0] = ((long) iL[12]); + long[] callResult_109 = ciRefInstance_109.getMachine().call(ciFuncId_109, callArgs_109); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_109[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + long[] callArgs_110 = new long[3]; + callArgs_110[2] = ((long) 0); + callArgs_110[1] = ((long) 25823); + callArgs_110[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_110); + } + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1176__h5(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_50: { + label_51: { + label_52: { + label_53: { + label_54: { + label_55: { + int _d6 = func_1176__h6(iL, memory, instance); + if (_d6 == 1) + break label_54; + if (_d6 == 2) + break label_53; + if (_d6 == 3) + break label_50; + if (_d6 == 4) + break label_51; + if (_d6 == 5) + break label_52; + if (_d6 >= 10000) { + _hs[0] = (_d6 - 10000); + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 20019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 48) + 16) < 0 ? ((iL[2] + 48) + 16) : ((iL[2] + 48) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 48) + 8) < 0 ? ((iL[2] + 48) + 8) : ((iL[2] + 48) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 48, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_27 = new long[3]; + callArgs_27[2] = ((long) iL[1]); + callArgs_27[1] = ((long) (iL[2] + 48)); + callArgs_27[0] = ((long) iL[0]); + long[] callResult_27 = instance.getMachine().call(1263, callArgs_27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_27[0])) != 0) { + { + _hs[0] = 20020; + break _hb; + } + } + { + _hs[0] = 20008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 20019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + long[] callArgs_28 = new long[1]; + callArgs_28[0] = ((long) (iL[2] + 1688)); + long[] callResult_28 = instance.getMachine().call(1264, callArgs_28); + iL[3] = ((int) callResult_28[0]); + long[] callArgs_29 = new long[3]; + callArgs_29[2] = ((long) (iL[2] + 1688)); + callArgs_29[1] = ((long) 0); + callArgs_29[0] = ((long) (iL[2] + 1632)); + long[] callResult_29 = instance.getMachine().call(155, callArgs_29); + iL[4] = ((int) callResult_29[0]); + long[] callArgs_30 = new long[3]; + callArgs_30[2] = ((long) iL[4]); + callArgs_30[1] = ((long) (iL[3] + 140)); + callArgs_30[0] = ((long) iL[0]); + long[] callResult_30 = instance.getMachine().call(1170, callArgs_30); + long[] callArgs_31 = new long[1]; + callArgs_31[0] = ((long) iL[4]); + long[] callResult_31 = instance.getMachine().call(162, callArgs_31); + label_68: { + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) (iL[3] + 36)); + callArgs_32[0] = ((long) iL[0]); + long[] callResult_32 = instance.getMachine().call(1232, callArgs_32); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_32[0])) != 0) { + break label_68; + } + long[] callArgs_33 = new long[2]; + callArgs_33[1] = ((long) (iL[3] + 76)); + callArgs_33[0] = ((long) iL[0]); + long[] callResult_33 = instance.getMachine().call(1233, callArgs_33); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_33[0])) != 0) { + break label_68; + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + { + _hs[0] = 20020; + break _hb; + } + } + int ciTableIdx_34 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_34 = instance.table(0).requiredRef(ciTableIdx_34); + com.dylibso.chicory.runtime.Instance ciRefInstance_34 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_34), instance); + if (!ciRefInstance_34.type(ciRefInstance_34.functionType(ciFuncId_34)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_34 = new long[1]; + callArgs_34[0] = ((long) iL[0]); + ciRefInstance_34.getMachine().call(ciFuncId_34, callArgs_34); + { + _hs[0] = 20020; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + int ciTableIdx_35 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_35 = instance.table(0).requiredRef(ciTableIdx_35); + com.dylibso.chicory.runtime.Instance ciRefInstance_35 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_35), instance); + if (!ciRefInstance_35.type(ciRefInstance_35.functionType(ciFuncId_35)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_35 = new long[1]; + callArgs_35[0] = ((long) iL[3]); + ciRefInstance_35.getMachine().call(ciFuncId_35, callArgs_35); + { + _hs[0] = 20008; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 20019; + break _hb; + } + } + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) (iL[2] + 1520)); + callArgs_36[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_36); + long[] callArgs_37 = new long[1]; + callArgs_37[0] = ((long) 72); + long[] callResult_37 = instance.getMachine().call(1776, callArgs_37); + iL[0] = ((int) callResult_37[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 14); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 48864); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + long[] callArgs_38 = new long[1]; + callArgs_38[0] = ((long) (iL[0] + 36)); + long[] callResult_38 = instance.getMachine().call(154, callArgs_38); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 20020; + break _hb; + } + } + int ciTableIdx_39 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_39 = instance.table(0).requiredRef(ciTableIdx_39); + com.dylibso.chicory.runtime.Instance ciRefInstance_39 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_39), instance); + if (!ciRefInstance_39.type(ciRefInstance_39.functionType(ciFuncId_39)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_39 = new long[1]; + callArgs_39[0] = ((long) iL[3]); + ciRefInstance_39.getMachine().call(ciFuncId_39, callArgs_39); + { + _hs[0] = 20020; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 20019; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_40 = new long[2]; + callArgs_40[1] = ((long) (iL[2] + 1520)); + callArgs_40[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_40); + memory.writeLong((int) ((iL[2] + 72) + 8) < 0 ? ((iL[2] + 72) + 8) : ((iL[2] + 72) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeI32((int) ((iL[2] + 72) + 16) < 0 ? ((iL[2] + 72) + 16) : ((iL[2] + 72) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 72, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_41 = new long[3]; + callArgs_41[2] = ((long) iL[1]); + callArgs_41[1] = ((long) (iL[2] + 72)); + callArgs_41[0] = ((long) iL[0]); + long[] callResult_41 = instance.getMachine().call(1265, callArgs_41); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_41[0])) != 0) { + { + _hs[0] = 20020; + break _hb; + } + } + { + _hs[0] = 20008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 20019; + break _hb; + } + } + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 1520) + 32) < 0 ? ((iL[2] + 1520) + 32) : ((iL[2] + 1520) + 32) + 0, (int) memory.readInt((int) (iL[3] + 32) < 0 ? (iL[3] + 32) : (iL[3] + 32) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 24) < 0 ? ((iL[2] + 1520) + 24) : ((iL[2] + 1520) + 24) + 0, (long) memory.readLong((int) (iL[3] + 24) < 0 ? (iL[3] + 24) : (iL[3] + 24) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 16) < 0 ? ((iL[2] + 1520) + 16) : ((iL[2] + 1520) + 16) + 0, (long) memory.readLong((int) (iL[3] + 16) < 0 ? (iL[3] + 16) : (iL[3] + 16) + 0)); + memory.writeLong((int) ((iL[2] + 1520) + 8) < 0 ? ((iL[2] + 1520) + 8) : ((iL[2] + 1520) + 8) + 0, (long) memory.readLong((int) (iL[3] + 8) < 0 ? (iL[3] + 8) : (iL[3] + 8) + 0)); + memory.writeByte((int) iL[3] < 0 ? iL[3] : iL[3] + 36, (byte) (0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 0)); + long[] callArgs_42 = new long[2]; + callArgs_42[1] = ((long) (iL[2] + 1520)); + callArgs_42[0] = ((long) iL[0]); + instance.getMachine().call(1162, callArgs_42); + long[] callArgs_43 = new long[1]; + callArgs_43[0] = ((long) (iL[2] + 1688)); + long[] callResult_43 = instance.getMachine().call(1266, callArgs_43); + iL[3] = ((int) callResult_43[0]); + long[] callArgs_44 = new long[3]; + callArgs_44[2] = ((long) (iL[2] + 1688)); + callArgs_44[1] = ((long) 0); + callArgs_44[0] = ((long) (iL[2] + 1592)); + long[] callResult_44 = instance.getMachine().call(155, callArgs_44); + iL[4] = ((int) callResult_44[0]); + long[] callArgs_45 = new long[3]; + callArgs_45[2] = ((long) iL[4]); + callArgs_45[1] = ((long) (iL[3] + 140)); + callArgs_45[0] = ((long) iL[0]); + long[] callResult_45 = instance.getMachine().call(1170, callArgs_45); + long[] callArgs_46 = new long[1]; + callArgs_46[0] = ((long) iL[4]); + long[] callResult_46 = instance.getMachine().call(162, callArgs_46); + label_69: { + long[] callArgs_47 = new long[2]; + callArgs_47[1] = ((long) (iL[3] + 36)); + callArgs_47[0] = ((long) iL[0]); + long[] callResult_47 = instance.getMachine().call(1232, callArgs_47); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_47[0])) != 0) { + break label_69; + } + long[] callArgs_48 = new long[2]; + callArgs_48[1] = ((long) (iL[3] + 76)); + callArgs_48[0] = ((long) iL[0]); + long[] callResult_48 = instance.getMachine().call(1233, callArgs_48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_48[0])) != 0) { + break label_69; + } + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + { + _hs[0] = 20020; + break _hb; + } + } + int ciTableIdx_49 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_49 = instance.table(0).requiredRef(ciTableIdx_49); + com.dylibso.chicory.runtime.Instance ciRefInstance_49 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_49), instance); + if (!ciRefInstance_49.type(ciRefInstance_49.functionType(ciFuncId_49)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_49 = new long[1]; + callArgs_49[0] = ((long) iL[0]); + ciRefInstance_49.getMachine().call(ciFuncId_49, callArgs_49); + { + _hs[0] = 20020; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + int ciTableIdx_50 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_50 = instance.table(0).requiredRef(ciTableIdx_50); + com.dylibso.chicory.runtime.Instance ciRefInstance_50 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_50), instance); + if (!ciRefInstance_50.type(ciRefInstance_50.functionType(ciFuncId_50)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_50 = new long[1]; + callArgs_50[0] = ((long) iL[3]); + ciRefInstance_50.getMachine().call(ciFuncId_50, callArgs_50); + { + _hs[0] = 20008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 20019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 96) + 16) < 0 ? ((iL[2] + 96) + 16) : ((iL[2] + 96) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 96) + 8) < 0 ? ((iL[2] + 96) + 8) : ((iL[2] + 96) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 96, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_51 = new long[3]; + callArgs_51[2] = ((long) iL[1]); + callArgs_51[1] = ((long) (iL[2] + 96)); + callArgs_51[0] = ((long) iL[0]); + long[] callResult_51 = instance.getMachine().call(1267, callArgs_51); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_51[0])) != 0) { + { + _hs[0] = 20020; + break _hb; + } + } + { + _hs[0] = 20008; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1871__h4(int[] iL, long[] lL, double[] dL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_67: { + label_68: { + label_69: { + label_70: { + label_71: { + label_72: { + label_73: { + label_74: { + iL[20] = (int) (byte) memory.read((int) (iL[1] + -1) < 0 ? (iL[1] + -1) : (iL[1] + -1) + 0); + iL[32] = (iL[23] != 0 ? (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(3, (iL[20] & 15)) != 0 ? (iL[20] & -33) : iL[20]) : iL[20]); + switch((iL[32] + -65)) { + case 0: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 1: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 2: + { + { + _hs[0] = 1; + break _hb; + } + } + case 3: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 4: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 5: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 6: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 7: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 8: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 9: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 10: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 11: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 12: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 13: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 14: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 15: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 16: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 17: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 18: + { + { + _hs[0] = 2; + break _hb; + } + } + case 19: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 20: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 21: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 22: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 23: + { + break label_71; + } + case 24: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 25: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 26: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 27: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 28: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 29: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 30: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 31: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 32: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 33: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 34: + { + break _hb; + } + case 35: + { + break label_69; + } + case 36: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 37: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 38: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 39: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 40: + { + break label_69; + } + case 41: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 42: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 43: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 44: + { + { + _hs[0] = 3; + break _hb; + } + } + case 45: + { + break label_73; + } + case 46: + { + break label_70; + } + case 47: + { + break label_72; + } + case 48: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 49: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 50: + { + { + _hs[0] = 4; + break _hb; + } + } + case 51: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 52: + { + break label_74; + } + case 53: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 54: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 55: + { + break label_71; + } + default: + { + { + _hs[0] = 20000; + break _hb; + } + } + } + } + iL[29] = 0; + iL[24] = 2575; + lL[1] = memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 56); + break label_68; + } + iL[20] = 0; + label_75: { + label_76: { + label_77: { + label_78: { + label_79: { + label_80: { + label_81: { + switch((iL[23] & 255)) { + case 0: + { + break label_81; + } + case 1: + { + break label_80; + } + case 2: + { + break label_79; + } + case 3: + { + break label_78; + } + case 4: + { + break label_77; + } + case 5: + { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 20002; + break _hb; + } + } + case 6: + { + break label_76; + } + case 7: + { + break label_75; + } + default: + { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 20002; + break _hb; + } + } + } + } + memory.writeI32((int) memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) < 0 ? memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) : memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) + 0, (int) iL[19]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 20002; + break _hb; + } + } + memory.writeI32((int) memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) < 0 ? memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) : memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) + 0, (int) iL[19]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 20002; + break _hb; + } + } + memory.writeLong((int) memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) < 0 ? memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) : memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) + 0, (long) (long) iL[19]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 20002; + break _hb; + } + } + memory.writeShort((int) memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) < 0 ? memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) : memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) + 0, (short) (iL[19])); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 20002; + break _hb; + } + } + memory.writeByte((int) memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) < 0 ? memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) : memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) + 0, (byte) (iL[19])); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 20002; + break _hb; + } + } + memory.writeI32((int) memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) < 0 ? memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) : memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) + 0, (int) iL[19]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 20002; + break _hb; + } + } + memory.writeLong((int) memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) < 0 ? memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) : memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 56) + 0, (long) (long) iL[19]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + { + _hs[0] = 20002; + break _hb; + } + } + iL[25] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[25], 8) != 0 ? iL[25] : 8); + iL[31] = (iL[31] | 8); + iL[32] = 120; + } + iL[29] = 0; + iL[24] = 2575; + label_82: { + lL[1] = memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(lL[1])) != 0) { + break label_82; + } + iL[21] = iL[17]; + break label_67; + } + iL[23] = (iL[32] & 32); + iL[21] = iL[17]; + label_83: while (true) { + iL[21] = (iL[21] + -1); + memory.writeByte((int) iL[21] < 0 ? iL[21] : iL[21] + 0, (byte) ((((int) memory.read((int) (((int) lL[1] & 15) + 62112) < 0 ? (((int) lL[1] & 15) + 62112) : (((int) lL[1] & 15) + 62112) + 0) & 0xFF) | iL[23]))); + iL[20] = com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(lL[1], 15L); + lL[1] = (lL[1] >>> 4L); + if (iL[20] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_83; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[31] & 8)) != 0) { + break label_67; + } + iL[24] = ((iL[32] >> 4) + 2575); + iL[29] = 2; + break label_67; + } + iL[21] = iL[17]; + label_84: { + lL[1] = memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(lL[1]) != 0) { + break label_84; + } + iL[21] = iL[17]; + label_85: while (true) { + iL[21] = (iL[21] + -1); + memory.writeByte((int) iL[21] < 0 ? iL[21] : iL[21] + 0, (byte) ((((int) lL[1] & 7) | 48))); + iL[20] = com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(lL[1], 7L); + lL[1] = (lL[1] >>> 3L); + if (iL[20] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_85; + } + break; + } + } + iL[29] = 0; + iL[24] = 2575; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[31] & 8)) != 0) { + break label_67; + } + iL[20] = (iL[17] - iL[21]); + iL[25] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[25], iL[20]) != 0 ? iL[25] : (iL[20] + 1)); + break label_67; + } + label_86: { + lL[1] = memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_S(lL[1], -1L) != 0) { + break label_86; + } + lL[1] = (0L - lL[1]); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 56, (long) lL[1]); + iL[29] = 1; + iL[24] = 2575; + break label_68; + } + label_87: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[31] & 2048)) != 0) { + break label_87; + } + iL[29] = 1; + iL[24] = 2576; + break label_68; + } + iL[29] = (iL[31] & 1); + iL[24] = (iL[29] != 0 ? 2577 : 2575); + } + label_88: { + label_89: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_GE_U(lL[1], 4294967296L) != 0) { + break label_89; + } + lL[2] = lL[1]; + iL[21] = iL[17]; + break label_88; + } + iL[21] = iL[17]; + label_90: while (true) { + iL[21] = (iL[21] + -1); + lL[2] = com.dylibso.chicory.runtime.OpcodeImpl.I64_DIV_U(lL[1], 10L); + memory.writeByte((int) iL[21] < 0 ? iL[21] : iL[21] + 0, (byte) (((int) (lL[1] - (lL[2] * 10L)) | 48))); + iL[20] = com.dylibso.chicory.runtime.OpcodeImpl.I64_GT_U(lL[1], 42949672959L); + lL[1] = lL[2]; + if (iL[20] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_90; + } + break; + } + } + iL[20] = (int) lL[2]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[20]) != 0) { + break label_67; + } + label_91: while (true) { + iL[21] = (iL[21] + -1); + iL[23] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_U(iL[20], 10); + memory.writeByte((int) iL[21] < 0 ? iL[21] : iL[21] + 0, (byte) (((iL[20] - (iL[23] * 10)) | 48))); + iL[26] = com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[20], 9); + iL[20] = iL[23]; + if (iL[26] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_91; + } + break; + } + } + label_92: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[28]) != 0) { + break label_92; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[25], 0) != 0) { + { + _hs[0] = 20001; + break _hb; + } + } + } + iL[30] = (iL[28] != 0 ? (iL[31] & -65537) : iL[31]); + label_93: { + lL[1] = memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(0L, lL[1]) != 0) { + break label_93; + } + iL[26] = 0; + if (iL[25] != 0) { + break label_93; + } + iL[21] = iL[17]; + iL[20] = iL[17]; + { + _hs[0] = 20004; + break _hb; + } + } + iL[20] = ((iL[17] - iL[21]) + com.dylibso.chicory.runtime.OpcodeImpl.I64_EQZ(lL[1])); + iL[26] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[25], iL[20]) != 0 ? iL[25] : iL[20]); + iL[20] = iL[17]; + { + _hs[0] = 20004; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_41__h4(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 124), memory.readInt((int) (iL[24] + 128) < 0 ? (iL[24] + 128) : (iL[24] + 128) + 0)) != 0) { + break _hb; + } + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) 1); + callArgs_32[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_32); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + long[] callArgs_33 = new long[3]; + callArgs_33[2] = ((long) 8498); + callArgs_33[1] = ((long) ((memory.readInt((int) (iL[24] + 128) < 0 ? (iL[24] + 128) : (iL[24] + 128) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 124)) >> 2)); + callArgs_33[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_33); + label_93: { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[19] = iL[24]; + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[24], memory.readInt((int) (iL[19] + 128) < 0 ? (iL[19] + 128) : (iL[19] + 128) + 0)) != 0) { + break label_93; + } + iL[31] = 0; + label_94: while (true) { + label_95: { + label_96: { + label_97: { + label_98: { + iL[24] = memory.readInt((int) (iL[24] + (iL[31] << 2)) < 0 ? (iL[24] + (iL[31] << 2)) : (iL[24] + (iL[31] << 2)) + 0); + switch(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 36)) { + case 0: + { + break label_98; + } + case 1: + { + break label_97; + } + case 2: + { + break label_96; + } + default: + { + break label_95; + } + } + } + label_99: { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[38] = memory.readInt((int) (iL[37] + 12) < 0 ? (iL[37] + 12) : (iL[37] + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_99; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 324, (int) iL[31]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 320, (int) 16358); + long[] callArgs_34 = new long[3]; + callArgs_34[2] = ((long) (iL[23] + 320)); + callArgs_34[1] = ((long) 32371); + callArgs_34[0] = ((long) iL[38]); + instance.getMachine().call(223, callArgs_34); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + } + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 312, (long) -32L); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 512, (long) -32L); + long[] callArgs_35 = new long[3]; + callArgs_35[2] = ((long) 0); + callArgs_35[1] = ((long) (iL[23] + 312)); + callArgs_35[0] = ((long) iL[37]); + instance.getMachine().call(37, callArgs_35); + iL[27] = memory.readInt((int) (iL[24] + 52) < 0 ? (iL[24] + 52) : (iL[24] + 52) + 0); + iL[26] = memory.readInt((int) (iL[24] + 56) < 0 ? (iL[24] + 56) : (iL[24] + 56) + 0); + iL[38] = memory.readInt((int) (iL[24] + 44) < 0 ? (iL[24] + 44) : (iL[24] + 44) + 0); + iL[36] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 40); + iL[37] = ((iL[38] - iL[36]) >> 3); + long[] callArgs_36 = new long[3]; + callArgs_36[2] = ((long) 8127); + callArgs_36[1] = ((long) iL[37]); + callArgs_36[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_36); + iL[25] = ((iL[26] - iL[27]) >> 3); + label_100: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[38]) != 0) { + break label_100; + } + iL[36] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[37], 1) != 0 ? iL[37] : 1); + iL[37] = 0; + label_101: while (true) { + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + lL[0] = memory.readLong((int) (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 40) + iL[37]) < 0 ? (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 40) + iL[37]) : (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 40) + iL[37]) + 0); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 384, (long) lL[0]); + long[] callArgs_37 = new long[2]; + callArgs_37[1] = ((long) (iL[23] + 384)); + callArgs_37[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(38, callArgs_37); + long[] callArgs_38 = new long[3]; + callArgs_38[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), 0) != 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) : (iL[23] + 560))); + callArgs_38[1] = ((long) (int) lL[0]); + callArgs_38[0] = ((long) iL[38]); + instance.getMachine().call(173, callArgs_38); + label_102: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), -1) != 0) { + break label_102; + } + long[] callArgs_39 = new long[1]; + callArgs_39[0] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560)); + instance.getMachine().call(1777, callArgs_39); + } + label_103: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 384)) != 0) { + break label_103; + } + iL[30] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 388); + long[] callArgs_40 = new long[2]; + callArgs_40[1] = ((long) (iL[23] + 384)); + callArgs_40[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(38, callArgs_40); + long[] callArgs_41 = new long[3]; + callArgs_41[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), 0) != 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) : (iL[23] + 560))); + callArgs_41[1] = ((long) iL[30]); + callArgs_41[0] = ((long) iL[38]); + instance.getMachine().call(173, callArgs_41); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), -1) != 0) { + break label_103; + } + long[] callArgs_42 = new long[1]; + callArgs_42[0] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560)); + instance.getMachine().call(1777, callArgs_42); + } + iL[37] = (iL[37] + 8); + iL[36] = (iL[36] + -1); + if (iL[36] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_101; + } + break; + } + } + long[] callArgs_43 = new long[3]; + callArgs_43[2] = ((long) 7742); + callArgs_43[1] = ((long) iL[25]); + callArgs_43[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_43); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[27], iL[26]) != 0) { + break label_95; + } + iL[36] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[25], 1) != 0 ? iL[25] : 1); + iL[37] = 0; + label_104: while (true) { + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + lL[0] = memory.readLong((int) (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 52) + iL[37]) < 0 ? (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 52) + iL[37]) : (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 52) + iL[37]) + 0); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 384, (long) lL[0]); + long[] callArgs_44 = new long[2]; + callArgs_44[1] = ((long) (iL[23] + 384)); + callArgs_44[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(38, callArgs_44); + long[] callArgs_45 = new long[3]; + callArgs_45[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), 0) != 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) : (iL[23] + 560))); + callArgs_45[1] = ((long) (int) lL[0]); + callArgs_45[0] = ((long) iL[38]); + instance.getMachine().call(173, callArgs_45); + label_105: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), -1) != 0) { + break label_105; + } + long[] callArgs_46 = new long[1]; + callArgs_46[0] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560)); + instance.getMachine().call(1777, callArgs_46); + } + label_106: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 384)) != 0) { + break label_106; + } + iL[30] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 388); + long[] callArgs_47 = new long[2]; + callArgs_47[1] = ((long) (iL[23] + 384)); + callArgs_47[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(38, callArgs_47); + long[] callArgs_48 = new long[3]; + callArgs_48[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), 0) != 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) : (iL[23] + 560))); + callArgs_48[1] = ((long) iL[30]); + callArgs_48[0] = ((long) iL[38]); + instance.getMachine().call(173, callArgs_48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), -1) != 0) { + break label_106; + } + long[] callArgs_49 = new long[1]; + callArgs_49[0] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560)); + instance.getMachine().call(1777, callArgs_49); + } + iL[37] = (iL[37] + 8); + iL[36] = (iL[36] + -1); + if (iL[36] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_104; + } + break label_95; + } + } + label_107: { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[38] = memory.readInt((int) (iL[37] + 12) < 0 ? (iL[37] + 12) : (iL[37] + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_107; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 340, (int) iL[31]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 336, (int) 15816); + long[] callArgs_50 = new long[3]; + callArgs_50[2] = ((long) (iL[23] + 336)); + callArgs_50[1] = ((long) 32371); + callArgs_50[0] = ((long) iL[38]); + instance.getMachine().call(223, callArgs_50); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + } + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 328, (long) -33L); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 504, (long) -33L); + long[] callArgs_51 = new long[3]; + callArgs_51[2] = ((long) 0); + callArgs_51[1] = ((long) (iL[23] + 328)); + callArgs_51[0] = ((long) iL[37]); + instance.getMachine().call(37, callArgs_51); + iL[38] = memory.readInt((int) (iL[24] + 44) < 0 ? (iL[24] + 44) : (iL[24] + 44) + 0); + iL[36] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 40); + iL[37] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((iL[38] - iL[36]), 24); + long[] callArgs_52 = new long[3]; + callArgs_52[2] = ((long) 8739); + callArgs_52[1] = ((long) iL[37]); + callArgs_52[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[38]) != 0) { + break label_95; + } + iL[36] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[37], 1) != 0 ? iL[37] : 1); + iL[37] = 12; + label_108: while (true) { + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[30] = (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 40) + iL[37]); + lL[0] = memory.readLong((int) iL[30] < 0 ? iL[30] : iL[30] + 0); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 384, (long) lL[0]); + long[] callArgs_53 = new long[2]; + callArgs_53[1] = ((long) (iL[23] + 384)); + callArgs_53[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(38, callArgs_53); + long[] callArgs_54 = new long[3]; + callArgs_54[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), 0) != 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) : (iL[23] + 560))); + callArgs_54[1] = ((long) (int) lL[0]); + callArgs_54[0] = ((long) iL[38]); + instance.getMachine().call(173, callArgs_54); + label_109: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), -1) != 0) { + break label_109; + } + long[] callArgs_55 = new long[1]; + callArgs_55[0] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560)); + instance.getMachine().call(1777, callArgs_55); + } + label_110: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 384)) != 0) { + break label_110; + } + iL[25] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 388); + long[] callArgs_56 = new long[2]; + callArgs_56[1] = ((long) (iL[23] + 384)); + callArgs_56[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(38, callArgs_56); + long[] callArgs_57 = new long[3]; + callArgs_57[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), 0) != 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) : (iL[23] + 560))); + callArgs_57[1] = ((long) iL[25]); + callArgs_57[0] = ((long) iL[38]); + instance.getMachine().call(173, callArgs_57); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), -1) != 0) { + break label_110; + } + long[] callArgs_58 = new long[1]; + callArgs_58[0] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560)); + instance.getMachine().call(1777, callArgs_58); + } + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (((int) memory.read((int) (iL[30] + 8) < 0 ? (iL[30] + 8) : (iL[30] + 8) + 0) & 0xFF))); + long[] callArgs_59 = new long[5]; + callArgs_59[4] = ((long) 0); + callArgs_59[3] = ((long) 1101); + callArgs_59[2] = ((long) 1); + callArgs_59[1] = ((long) (iL[23] + 560)); + callArgs_59[0] = ((long) iL[38]); + instance.getMachine().call(224, callArgs_59); + iL[37] = (iL[37] + 24); + iL[36] = (iL[36] + -1); + if (iL[36] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_108; + } + break label_95; + } + } + label_111: { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[38] = memory.readInt((int) (iL[37] + 12) < 0 ? (iL[37] + 12) : (iL[37] + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_111; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 372, (int) iL[31]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 368, (int) 15730); + long[] callArgs_60 = new long[3]; + callArgs_60[2] = ((long) (iL[23] + 368)); + callArgs_60[1] = ((long) 32371); + callArgs_60[0] = ((long) iL[38]); + instance.getMachine().call(223, callArgs_60); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + } + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 360, (long) -34L); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 496, (long) -34L); + long[] callArgs_61 = new long[3]; + callArgs_61[2] = ((long) 0); + callArgs_61[1] = ((long) (iL[23] + 360)); + callArgs_61[0] = ((long) iL[37]); + instance.getMachine().call(37, callArgs_61); + lL[0] = memory.readLong((int) (iL[24] + 52) < 0 ? (iL[24] + 52) : (iL[24] + 52) + 0); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 488, (long) lL[0]); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 352, (long) lL[0]); + long[] callArgs_62 = new long[3]; + callArgs_62[2] = ((long) 0); + callArgs_62[1] = ((long) (iL[23] + 352)); + callArgs_62[0] = ((long) iL[37]); + instance.getMachine().call(37, callArgs_62); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (((int) memory.read((int) (iL[24] + 60) < 0 ? (iL[24] + 60) : (iL[24] + 60) + 0) & 0xFF))); + long[] callArgs_63 = new long[5]; + callArgs_63[4] = ((long) 0); + callArgs_63[3] = ((long) 1101); + callArgs_63[2] = ((long) 1); + callArgs_63[1] = ((long) (iL[23] + 560)); + callArgs_63[0] = ((long) iL[37]); + instance.getMachine().call(224, callArgs_63); + } + iL[31] = (iL[31] + 1); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[18] = iL[24]; + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[31], ((memory.readInt((int) (iL[18] + 128) < 0 ? (iL[18] + 128) : (iL[18] + 128) + 0) - iL[24]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_94; + } + break; + } + } + long[] callArgs_64 = new long[4]; + callArgs_64[3] = ((long) 15012); + callArgs_64[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_64[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_64[0] = ((long) iL[0]); + long[] callResult_64 = instance.getMachine().call(48, callArgs_64); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } while (false); + return _hs[0]; + } + + private static int func_801__h6(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_459: { + label_460: { + label_461: { + int _d14 = func_801__h14(iL, lL, memory, instance); + if (_d14 == 1) + break label_459; + if (_d14 == 2) + break label_460; + if (_d14 >= 10000) { + _hs[0] = (_d14 - 10000); + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + break _hb; + } + label_490: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_543 = new long[3]; + callArgs_543[2] = ((long) (iL[4] + 3136)); + callArgs_543[1] = ((long) (iL[15] + iL[3])); + callArgs_543[0] = ((long) (iL[15] + iL[13])); + long[] callResult_543 = instance.getMachine().call(177, callArgs_543); + iL[13] = ((int) callResult_543[0]); + if (iL[13] != 0) { + break label_490; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1216, (int) 6683); + long[] callArgs_544 = new long[3]; + callArgs_544[2] = ((long) (iL[4] + 1216)); + callArgs_544[1] = ((long) 11260); + callArgs_544[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_544); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + label_491: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_545 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 852)); + int ciFuncId_545 = instance.table(0).requiredRef(ciTableIdx_545); + com.dylibso.chicory.runtime.Instance ciRefInstance_545 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_545), instance); + if (!ciRefInstance_545.type(ciRefInstance_545.functionType(ciFuncId_545)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_545 = new long[2]; + callArgs_545[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136)); + callArgs_545[0] = ((long) iL[13]); + long[] callResult_545 = ciRefInstance_545.getMachine().call(ciFuncId_545, callArgs_545); + if (((int) callResult_545[0]) != 0) { + break label_491; + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3136, (int) (iL[13] + -1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break _hb; + } + label_492: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_546 = new long[3]; + callArgs_546[2] = ((long) 16822); + callArgs_546[1] = ((long) (iL[4] + 3168)); + callArgs_546[0] = ((long) (iL[4] + 2936)); + long[] callResult_546 = instance.getMachine().call(803, callArgs_546); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_546[0])) != 0) { + { + _hs[0] = 10014; + break _hb; + } + } + label_493: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_547 = new long[3]; + callArgs_547[2] = ((long) (iL[4] + 3160)); + callArgs_547[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_547[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_547 = instance.getMachine().call(177, callArgs_547); + iL[15] = ((int) callResult_547[0]); + if (iL[15] != 0) { + break label_493; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1232, (int) 8329); + long[] callArgs_548 = new long[3]; + callArgs_548[2] = ((long) (iL[4] + 1232)); + callArgs_548[1] = ((long) 11260); + callArgs_548[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_548); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[15] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[15]); + label_494: { + long[] callArgs_549 = new long[3]; + callArgs_549[2] = ((long) (iL[4] + 3128)); + callArgs_549[1] = ((long) (iL[13] + iL[16])); + callArgs_549[0] = ((long) (iL[13] + iL[15])); + long[] callResult_549 = instance.getMachine().call(177, callArgs_549); + iL[13] = ((int) callResult_549[0]); + if (iL[13] != 0) { + break label_494; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1248, (int) 6139); + long[] callArgs_550 = new long[3]; + callArgs_550[2] = ((long) (iL[4] + 1248)); + callArgs_550[1] = ((long) 11260); + callArgs_550[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_550); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3208, (long) lL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[15] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 856); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1288, (long) lL[0]); + label_495: { + int ciTableIdx_551 = (int) (iL[15]); + int ciFuncId_551 = instance.table(0).requiredRef(ciTableIdx_551); + com.dylibso.chicory.runtime.Instance ciRefInstance_551 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_551), instance); + if (!ciRefInstance_551.type(ciRefInstance_551.functionType(ciFuncId_551)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_551 = new long[4]; + callArgs_551[3] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3128)); + callArgs_551[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160)); + callArgs_551[1] = ((long) (iL[4] + 1288)); + callArgs_551[0] = ((long) iL[13]); + long[] callResult_551 = ciRefInstance_551.getMachine().call(ciFuncId_551, callArgs_551); + if (((int) callResult_551[0]) != 0) { + break label_495; + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3128); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3128, (int) (iL[13] + -1)); + label_496: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_496; + } + label_497: while (true) { + label_498: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_552 = new long[3]; + callArgs_552[2] = ((long) (iL[4] + 3120)); + callArgs_552[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_552[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_552 = instance.getMachine().call(177, callArgs_552); + iL[15] = ((int) callResult_552[0]); + if (iL[15] != 0) { + break label_498; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1264, (int) 17689); + long[] callArgs_553 = new long[3]; + callArgs_553[2] = ((long) (iL[4] + 1264)); + callArgs_553[1] = ((long) 11260); + callArgs_553[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_553); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[15] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[15]); + label_499: { + long[] callArgs_554 = new long[3]; + callArgs_554[2] = ((long) (iL[4] + 3112)); + callArgs_554[1] = ((long) (iL[13] + iL[16])); + callArgs_554[0] = ((long) (iL[13] + iL[15])); + long[] callResult_554 = instance.getMachine().call(177, callArgs_554); + iL[13] = ((int) callResult_554[0]); + if (iL[13] != 0) { + break label_499; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1280, (int) 2231); + long[] callArgs_555 = new long[3]; + callArgs_555[2] = ((long) (iL[4] + 1280)); + callArgs_555[1] = ((long) 11260); + callArgs_555[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_555); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + label_500: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_556 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 860)); + int ciFuncId_556 = instance.table(0).requiredRef(ciTableIdx_556); + com.dylibso.chicory.runtime.Instance ciRefInstance_556 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_556), instance); + if (!ciRefInstance_556.type(ciRefInstance_556.functionType(ciFuncId_556)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_556 = new long[3]; + callArgs_556[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3112)); + callArgs_556[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3120)); + callArgs_556[0] = ((long) iL[13]); + long[] callResult_556 = ciRefInstance_556.getMachine().call(ciFuncId_556, callArgs_556); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_556[0])) != 0) { + break label_500; + } + long[] callArgs_557 = new long[3]; + callArgs_557[2] = ((long) 0); + callArgs_557[1] = ((long) 18901); + callArgs_557[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_557); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3128); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3128, (int) (iL[13] + -1)); + if (iL[13] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_497; + } + break; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3136, (int) (iL[13] + -1)); + if (iL[13] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_492; + } + break _hb; + } + break; + } + long[] callArgs_558 = new long[3]; + callArgs_558[2] = ((long) 0); + callArgs_558[1] = ((long) 24715); + callArgs_558[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_558); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + long[] callArgs_559 = new long[3]; + callArgs_559[2] = ((long) 0); + callArgs_559[1] = ((long) 19491); + callArgs_559[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_559); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + label_501: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_560 = new long[3]; + callArgs_560[2] = ((long) (iL[4] + 3136)); + callArgs_560[1] = ((long) (iL[15] + iL[3])); + callArgs_560[0] = ((long) (iL[15] + iL[13])); + long[] callResult_560 = instance.getMachine().call(177, callArgs_560); + iL[13] = ((int) callResult_560[0]); + if (iL[13] != 0) { + break label_501; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1168, (int) 6345); + long[] callArgs_561 = new long[3]; + callArgs_561[2] = ((long) (iL[4] + 1168)); + callArgs_561[1] = ((long) 11260); + callArgs_561[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_561); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_562 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 844)); + int ciFuncId_562 = instance.table(0).requiredRef(ciTableIdx_562); + com.dylibso.chicory.runtime.Instance ciRefInstance_562 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_562), instance); + if (!ciRefInstance_562.type(ciRefInstance_562.functionType(ciFuncId_562)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_562 = new long[2]; + callArgs_562[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136)); + callArgs_562[0] = ((long) iL[13]); + long[] callResult_562 = ciRefInstance_562.getMachine().call(ciFuncId_562, callArgs_562); + if (((int) callResult_562[0]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3136, (int) (iL[13] + -1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break _hb; + } + label_502: while (true) { + label_503: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_563 = new long[3]; + callArgs_563[2] = ((long) (iL[4] + 3168)); + callArgs_563[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_563[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_563 = instance.getMachine().call(177, callArgs_563); + iL[15] = ((int) callResult_563[0]); + if (iL[15] != 0) { + break label_503; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1184, (int) 1074); + long[] callArgs_564 = new long[3]; + callArgs_564[2] = ((long) (iL[4] + 1184)); + callArgs_564[1] = ((long) 11260); + callArgs_564[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_564); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[15] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[15]); + label_504: { + long[] callArgs_565 = new long[3]; + callArgs_565[2] = ((long) (iL[4] + 3160)); + callArgs_565[1] = ((long) (iL[13] + iL[16])); + callArgs_565[0] = ((long) (iL[13] + iL[15])); + long[] callResult_565 = instance.getMachine().call(177, callArgs_565); + iL[13] = ((int) callResult_565[0]); + if (iL[13] != 0) { + break label_504; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1200, (int) 1628); + long[] callArgs_566 = new long[3]; + callArgs_566[2] = ((long) (iL[4] + 1200)); + callArgs_566[1] = ((long) 11260); + callArgs_566[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_566); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + label_505: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_567 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 848)); + int ciFuncId_567 = instance.table(0).requiredRef(ciTableIdx_567); + com.dylibso.chicory.runtime.Instance ciRefInstance_567 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_567), instance); + if (!ciRefInstance_567.type(ciRefInstance_567.functionType(ciFuncId_567)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_567 = new long[3]; + callArgs_567[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160)); + callArgs_567[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168)); + callArgs_567[0] = ((long) iL[13]); + long[] callResult_567 = ciRefInstance_567.getMachine().call(ciFuncId_567, callArgs_567); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_567[0])) != 0) { + break label_505; + } + long[] callArgs_568 = new long[3]; + callArgs_568[2] = ((long) 0); + callArgs_568[1] = ((long) 22986); + callArgs_568[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_568); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3136, (int) (iL[13] + -1)); + if (iL[13] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_502; + } + break; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h6(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_67: { + label_68: { + label_69: { + label_70: { + label_71: { + label_72: { + label_73: { + int _d3 = func_804__h3(iL, lL, memory, instance); + if (_d3 == 1) + break label_72; + if (_d3 == 2) + break label_69; + if (_d3 == 3) + break label_70; + if (_d3 == 4) + break label_71; + if (_d3 == 5) { + _hs[0] = 1; + break _hb; + } + if (_d3 == 6) { + _hs[0] = 2; + break _hb; + } + if (_d3 == 7) { + _hs[0] = 3; + break _hb; + } + if (_d3 == 8) { + _hs[0] = 4; + break _hb; + } + if (_d3 >= 10000) { + _hs[0] = ((_d3 - 10000)) + 10000; + break _hb; + } + } + label_247: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 144)) != 0) { + break label_247; + } + long[] callArgs_270 = new long[3]; + callArgs_270[2] = ((long) 0); + callArgs_270[1] = ((long) 12413); + callArgs_270[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_270); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + label_248: { + long[] callArgs_271 = new long[3]; + callArgs_271[2] = ((long) 1473); + callArgs_271[1] = ((long) (iL[3] + 352)); + callArgs_271[0] = ((long) iL[0]); + long[] callResult_271 = instance.getMachine().call(814, callArgs_271); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_271[0])) != 0) { + break label_248; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 336, (int) 0); + label_249: { + label_250: { + if (((int) memory.read((int) memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) < 0 ? memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) : memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) + 15) & 0xFF) != 0) { + break label_250; + } + long[] callArgs_272 = new long[3]; + callArgs_272[2] = ((long) 1451); + callArgs_272[1] = ((long) (iL[3] + 348)); + callArgs_272[0] = ((long) iL[0]); + long[] callResult_272 = instance.getMachine().call(811, callArgs_272); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_272[0])) != 0) { + break label_248; + } + label_251: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 348) & 0xFF)) != 0) { + break label_251; + } + long[] callArgs_273 = new long[3]; + callArgs_273[2] = ((long) 0); + callArgs_273[1] = ((long) 28714); + callArgs_273[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_273); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + iL[4] = 0; + break label_249; + } + long[] callArgs_274 = new long[3]; + callArgs_274[2] = ((long) 2329); + callArgs_274[1] = ((long) (iL[3] + 336)); + callArgs_274[0] = ((long) iL[0]); + long[] callResult_274 = instance.getMachine().call(828, callArgs_274); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_274[0])) != 0) { + break label_248; + } + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + } + label_252: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[11] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_275 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 440)); + int ciFuncId_275 = instance.table(0).requiredRef(ciTableIdx_275); + com.dylibso.chicory.runtime.Instance ciRefInstance_275 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_275), instance); + if (!ciRefInstance_275.type(ciRefInstance_275.functionType(ciFuncId_275)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_275 = new long[3]; + callArgs_275[2] = ((long) iL[4]); + callArgs_275[1] = ((long) iL[11]); + callArgs_275[0] = ((long) iL[12]); + long[] callResult_275 = ciRefInstance_275.getMachine().call(ciFuncId_275, callArgs_275); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_275[0])) != 0) { + break label_252; + } + long[] callArgs_276 = new long[3]; + callArgs_276[2] = ((long) 0); + callArgs_276[1] = ((long) 20900); + callArgs_276[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_276); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_277 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 244)); + int ciFuncId_277 = instance.table(0).requiredRef(ciTableIdx_277); + com.dylibso.chicory.runtime.Instance ciRefInstance_277 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_277), instance); + if (!ciRefInstance_277.type(ciRefInstance_277.functionType(ciFuncId_277)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_277 = new long[3]; + callArgs_277[2] = ((long) iL[4]); + callArgs_277[1] = ((long) iL[11]); + callArgs_277[0] = ((long) iL[12]); + long[] callResult_277 = ciRefInstance_277.getMachine().call(ciFuncId_277, callArgs_277); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_277[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + long[] callArgs_278 = new long[3]; + callArgs_278[2] = ((long) 0); + callArgs_278[1] = ((long) 25823); + callArgs_278[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_278); + } + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-1, memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 144)) != 0) { + break label_71; + } + long[] callArgs_279 = new long[3]; + callArgs_279[2] = ((long) 0); + callArgs_279[1] = ((long) 12453); + callArgs_279[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_279); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_280 = new long[3]; + callArgs_280[2] = ((long) 1478); + callArgs_280[1] = ((long) (iL[3] + 352)); + callArgs_280[0] = ((long) iL[0]); + long[] callResult_280 = instance.getMachine().call(814, callArgs_280); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_280[0])) != 0) { + { + _hs[0] = 10007; + break _hb; + } + } + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[10] = memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + label_253: { + label_254: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(205, memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)) != 0) { + break label_254; + } + int ciTableIdx_281 = (int) (memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 428)); + int ciFuncId_281 = instance.table(0).requiredRef(ciTableIdx_281); + com.dylibso.chicory.runtime.Instance ciRefInstance_281 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_281), instance); + if (!ciRefInstance_281.type(ciRefInstance_281.functionType(ciFuncId_281)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_281 = new long[2]; + callArgs_281[1] = ((long) iL[4]); + callArgs_281[0] = ((long) iL[12]); + long[] callResult_281 = ciRefInstance_281.getMachine().call(ciFuncId_281, callArgs_281); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_281[0])) != 0) { + break label_253; + } + iL[4] = 21636; + { + _hs[0] = 10044; + break _hb; + } + } + int ciTableIdx_282 = (int) (memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 452)); + int ciFuncId_282 = instance.table(0).requiredRef(ciTableIdx_282); + com.dylibso.chicory.runtime.Instance ciRefInstance_282 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_282), instance); + if (!ciRefInstance_282.type(ciRefInstance_282.functionType(ciFuncId_282)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_282 = new long[2]; + callArgs_282[1] = ((long) iL[4]); + callArgs_282[0] = ((long) iL[12]); + long[] callResult_282 = ciRefInstance_282.getMachine().call(ciFuncId_282, callArgs_282); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_282[0])) != 0) { + break label_253; + } + iL[4] = 21605; + { + _hs[0] = 10044; + break _hb; + } + } + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_283 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 232)); + int ciFuncId_283 = instance.table(0).requiredRef(ciTableIdx_283); + com.dylibso.chicory.runtime.Instance ciRefInstance_283 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_283), instance); + if (!ciRefInstance_283.type(ciRefInstance_283.functionType(ciFuncId_283)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_283 = new long[2]; + callArgs_283[1] = ((long) iL[4]); + callArgs_283[0] = ((long) iL[12]); + long[] callResult_283 = ciRefInstance_283.getMachine().call(ciFuncId_283, callArgs_283); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_283[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + iL[4] = 25792; + { + _hs[0] = 10044; + break _hb; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 352, (int) 0); + label_255: { + label_256: { + if (((int) memory.read((int) memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) < 0 ? memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) : memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) + 15) & 0xFF) != 0) { + break label_256; + } + long[] callArgs_284 = new long[3]; + callArgs_284[2] = ((long) 18733); + callArgs_284[1] = ((long) (iL[3] + 336)); + callArgs_284[0] = ((long) iL[0]); + long[] callResult_284 = instance.getMachine().call(811, callArgs_284); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_284[0])) != 0) { + break label_68; + } + label_257: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 336) & 0xFF)) != 0) { + break label_257; + } + long[] callArgs_285 = new long[3]; + callArgs_285[2] = ((long) 0); + callArgs_285[1] = ((long) 28665); + callArgs_285[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_285); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + iL[4] = 0; + break label_255; + } + long[] callArgs_286 = new long[3]; + callArgs_286[2] = ((long) 2360); + callArgs_286[1] = ((long) (iL[3] + 352)); + callArgs_286[0] = ((long) iL[0]); + long[] callResult_286 = instance.getMachine().call(828, callArgs_286); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_286[0])) != 0) { + break label_68; + } + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + } + label_258: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_287 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 432)); + int ciFuncId_287 = instance.table(0).requiredRef(ciTableIdx_287); + com.dylibso.chicory.runtime.Instance ciRefInstance_287 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_287), instance); + if (!ciRefInstance_287.type(ciRefInstance_287.functionType(ciFuncId_287)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_287 = new long[2]; + callArgs_287[1] = ((long) iL[4]); + callArgs_287[0] = ((long) iL[12]); + long[] callResult_287 = ciRefInstance_287.getMachine().call(ciFuncId_287, callArgs_287); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_287[0])) != 0) { + break label_258; + } + long[] callArgs_288 = new long[3]; + callArgs_288[2] = ((long) 0); + callArgs_288[1] = ((long) 21969); + callArgs_288[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_288); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_289 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 232)); + int ciFuncId_289 = instance.table(0).requiredRef(ciTableIdx_289); + com.dylibso.chicory.runtime.Instance ciRefInstance_289 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_289), instance); + if (!ciRefInstance_289.type(ciRefInstance_289.functionType(ciFuncId_289)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_289 = new long[2]; + callArgs_289[1] = ((long) iL[4]); + callArgs_289[0] = ((long) iL[12]); + long[] callResult_289 = ciRefInstance_289.getMachine().call(ciFuncId_289, callArgs_289); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_289[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + long[] callArgs_290 = new long[3]; + callArgs_290[2] = ((long) 0); + callArgs_290[1] = ((long) 25792); + callArgs_290[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_290); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 352, (int) 0); + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 336, (int) 0); + label_259: { + label_260: { + if (((int) memory.read((int) memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) < 0 ? memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) : memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) + 15) & 0xFF) != 0) { + break label_260; + } + long[] callArgs_291 = new long[3]; + callArgs_291[2] = ((long) 1451); + callArgs_291[1] = ((long) (iL[3] + 348)); + callArgs_291[0] = ((long) iL[0]); + long[] callResult_291 = instance.getMachine().call(811, callArgs_291); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_291[0])) != 0) { + break label_68; + } + if (((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 348) & 0xFF) != 0) { + break _hb; + } + long[] callArgs_292 = new long[3]; + callArgs_292[2] = ((long) 1451); + callArgs_292[1] = ((long) (iL[3] + 348)); + callArgs_292[0] = ((long) iL[0]); + long[] callResult_292 = instance.getMachine().call(811, callArgs_292); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_292[0])) != 0) { + break label_68; + } + if (((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 348) & 0xFF) != 0) { + break _hb; + } + iL[4] = 0; + iL[12] = 0; + break label_259; + } + long[] callArgs_293 = new long[3]; + callArgs_293[2] = ((long) 1380); + callArgs_293[1] = ((long) (iL[3] + 352)); + callArgs_293[0] = ((long) iL[0]); + long[] callResult_293 = instance.getMachine().call(828, callArgs_293); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_293[0])) != 0) { + break label_68; + } + long[] callArgs_294 = new long[3]; + callArgs_294[2] = ((long) 2260); + callArgs_294[1] = ((long) (iL[3] + 336)); + callArgs_294[0] = ((long) iL[0]); + long[] callResult_294 = instance.getMachine().call(828, callArgs_294); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_294[0])) != 0) { + break label_68; + } + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + } + iL[11] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_295 = (int) (memory.readInt((int) memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0) < 0 ? memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0) : memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0) + 424)); + int ciFuncId_295 = instance.table(0).requiredRef(ciTableIdx_295); + com.dylibso.chicory.runtime.Instance ciRefInstance_295 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_295), instance); + if (!ciRefInstance_295.type(ciRefInstance_295.functionType(ciFuncId_295)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_295 = new long[3]; + callArgs_295[2] = ((long) iL[4]); + callArgs_295[1] = ((long) iL[12]); + callArgs_295[0] = ((long) iL[11]); + long[] callResult_295 = ciRefInstance_295.getMachine().call(ciFuncId_295, callArgs_295); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_295[0])) != 0) { + break label_67; + } + long[] callArgs_296 = new long[3]; + callArgs_296[2] = ((long) 0); + callArgs_296[1] = ((long) 20459); + callArgs_296[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_296); + } + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } + iL[11] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_297 = (int) (memory.readInt((int) memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0) < 0 ? memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0) : memory.readInt((int) iL[11] < 0 ? iL[11] : iL[11] + 0) + 244)); + int ciFuncId_297 = instance.table(0).requiredRef(ciTableIdx_297); + com.dylibso.chicory.runtime.Instance ciRefInstance_297 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_297), instance); + if (!ciRefInstance_297.type(ciRefInstance_297.functionType(ciFuncId_297)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_297 = new long[3]; + callArgs_297[2] = ((long) iL[4]); + callArgs_297[1] = ((long) iL[12]); + callArgs_297[0] = ((long) iL[11]); + long[] callResult_297 = ciRefInstance_297.getMachine().call(ciFuncId_297, callArgs_297); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_297[0])) != 0) { + { + _hs[0] = 10008; + break _hb; + } + } + long[] callArgs_298 = new long[3]; + callArgs_298[2] = ((long) 0); + callArgs_298[1] = ((long) 25823); + callArgs_298[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_298); + iL[11] = 1; + { + _hs[0] = 10007; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h7(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_52: { + label_53: { + int _d5 = func_801__h5(iL, lL, memory, instance); + if (_d5 == 1) { + _hs[0] = 1; + break _hb; + } + if (_d5 == 2) { + _hs[0] = 2; + break _hb; + } + if (_d5 == 3) { + _hs[0] = 3; + break _hb; + } + if (_d5 == 4) + break _hb; + if (_d5 == 5) + break label_52; + if (_d5 >= 10000) { + _hs[0] = ((_d5 - 10000)) + 10000; + break _hb; + } + } + label_191: { + label_192: { + label_193: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_200 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 200)); + int ciFuncId_200 = instance.table(0).requiredRef(ciTableIdx_200); + com.dylibso.chicory.runtime.Instance ciRefInstance_200 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_200), instance); + if (!ciRefInstance_200.type(ciRefInstance_200.functionType(ciFuncId_200)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_200 = new long[2]; + callArgs_200[1] = ((long) iL[0]); + callArgs_200[0] = ((long) iL[3]); + long[] callResult_200 = ciRefInstance_200.getMachine().call(ciFuncId_200, callArgs_200); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_200[0])) != 0) { + break label_193; + } + long[] callArgs_201 = new long[3]; + callArgs_201[2] = ((long) 0); + callArgs_201[1] = ((long) 24441); + callArgs_201[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_201); + break label_192; + } + label_194: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_202 = new long[3]; + callArgs_202[2] = ((long) (iL[4] + 3168)); + callArgs_202[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_202[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_202 = instance.getMachine().call(177, callArgs_202); + iL[0] = ((int) callResult_202[0]); + if (iL[0] != 0) { + break label_194; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2528, (int) 6192); + long[] callArgs_203 = new long[3]; + callArgs_203[2] = ((long) (iL[4] + 2528)); + callArgs_203[1] = ((long) 11260); + callArgs_203[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_203); + break label_192; + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3072, (int) iL[3]); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_195: { + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_195; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2552, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2548, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2544, (int) 6192); + long[] callArgs_204 = new long[3]; + callArgs_204[2] = ((long) (iL[4] + 2544)); + callArgs_204[1] = ((long) 12552); + callArgs_204[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_204); + break label_192; + } + label_196: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3068)) != 0) { + break label_196; + } + long[] callArgs_205 = new long[3]; + callArgs_205[2] = ((long) 0); + callArgs_205[1] = ((long) 6164); + callArgs_205[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_205); + break label_192; + } + label_197: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_206 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 204)); + int ciFuncId_206 = instance.table(0).requiredRef(ciTableIdx_206); + com.dylibso.chicory.runtime.Instance ciRefInstance_206 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_206), instance); + if (!ciRefInstance_206.type(ciRefInstance_206.functionType(ciFuncId_206)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_206 = new long[2]; + callArgs_206[1] = ((long) iL[3]); + callArgs_206[0] = ((long) iL[0]); + long[] callResult_206 = ciRefInstance_206.getMachine().call(ciFuncId_206, callArgs_206); + if (((int) callResult_206[0]) != 0) { + break label_197; + } + label_198: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3072)) != 0) { + break label_198; + } + iL[16] = 0; + label_199: while (true) { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3048); + label_200: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_207 = new long[3]; + callArgs_207[2] = ((long) (iL[4] + 3248)); + callArgs_207[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_207[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_207 = instance.getMachine().call(177, callArgs_207); + iL[3] = ((int) callResult_207[0]); + if (iL[3] != 0) { + break label_200; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2560, (int) 14932); + long[] callArgs_208 = new long[3]; + callArgs_208[2] = ((long) (iL[4] + 2560)); + callArgs_208[1] = ((long) 11260); + callArgs_208[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_208); + break label_192; + } + iL[17] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[17]); + label_201: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[19] = (iL[0] + iL[16]); + iL[18] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3248); + int ciTableIdx_209 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 208)); + int ciFuncId_209 = instance.table(0).requiredRef(ciTableIdx_209); + com.dylibso.chicory.runtime.Instance ciRefInstance_209 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_209), instance); + if (!ciRefInstance_209.type(ciRefInstance_209.functionType(ciFuncId_209)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_209 = new long[3]; + callArgs_209[2] = ((long) iL[18]); + callArgs_209[1] = ((long) iL[19]); + callArgs_209[0] = ((long) iL[3]); + long[] callResult_209 = ciRefInstance_209.getMachine().call(ciFuncId_209, callArgs_209); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_209[0])) != 0) { + break label_201; + } + long[] callArgs_210 = new long[3]; + callArgs_210[2] = ((long) 0); + callArgs_210[1] = ((long) 19015); + callArgs_210[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_210); + break label_192; + } + label_202: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_211 = new long[3]; + callArgs_211[2] = ((long) (iL[4] + 3168)); + callArgs_211[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_211[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_211 = instance.getMachine().call(177, callArgs_211); + iL[3] = ((int) callResult_211[0]); + if (iL[3] != 0) { + break label_202; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2576, (int) 6371); + long[] callArgs_212 = new long[3]; + callArgs_212[2] = ((long) (iL[4] + 2576)); + callArgs_212[1] = ((long) 11260); + callArgs_212[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_212); + break label_192; + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_203: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[15], iL[3]) != 0) { + break label_203; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2600, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2596, (int) iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2592, (int) 6371); + long[] callArgs_213 = new long[3]; + callArgs_213[2] = ((long) (iL[4] + 2592)); + callArgs_213[1] = ((long) 12552); + callArgs_213[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_213); + break label_192; + } + label_204: { + label_205: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_214 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 212)); + int ciFuncId_214 = instance.table(0).requiredRef(ciTableIdx_214); + com.dylibso.chicory.runtime.Instance ciRefInstance_214 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_214), instance); + if (!ciRefInstance_214.type(ciRefInstance_214.functionType(ciFuncId_214)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_214 = new long[2]; + callArgs_214[1] = ((long) iL[15]); + callArgs_214[0] = ((long) iL[3]); + long[] callResult_214 = ciRefInstance_214.getMachine().call(ciFuncId_214, callArgs_214); + if (((int) callResult_214[0]) != 0) { + break label_205; + } + label_206: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[15]) != 0) { + break label_206; + } + iL[3] = 0; + lL[1] = 0L; + label_207: while (true) { + label_208: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_215 = new long[3]; + callArgs_215[2] = ((long) (iL[4] + 3168)); + callArgs_215[1] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_215[0] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_215 = instance.getMachine().call(177, callArgs_215); + iL[0] = ((int) callResult_215[0]); + if (iL[0] != 0) { + break label_208; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2608, (int) 6578); + long[] callArgs_216 = new long[3]; + callArgs_216[2] = ((long) (iL[4] + 2608)); + callArgs_216[1] = ((long) 11260); + callArgs_216[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_216); + break label_192; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0])); + label_209: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + lL[1] = (lL[1] + com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(iL[0])); + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_LT_U(lL[1], 4294967296L) != 0) { + break label_209; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2624, (int) -1); + long[] callArgs_217 = new long[3]; + callArgs_217[2] = ((long) (iL[4] + 2624)); + callArgs_217[1] = ((long) 2604); + callArgs_217[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_217); + break label_192; + } + long[] callArgs_218 = new long[3]; + callArgs_218[2] = ((long) 15965); + callArgs_218[1] = ((long) (iL[4] + 3168)); + callArgs_218[0] = ((long) (iL[4] + 2936)); + long[] callResult_218 = instance.getMachine().call(805, callArgs_218); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_218[0])) != 0) { + break label_192; + } + iL[14] = 15950; + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036); + label_210: { + label_211: { + label_212: { + label_213: { + label_214: { + label_215: { + label_216: { + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + switch(((int) lL[0] + 23)) { + case 0: + { + break label_215; + } + case 1: + { + break label_211; + } + case 2: + { + break label_214; + } + case 3: + { + break label_211; + } + case 4: + { + break label_211; + } + case 5: + { + break label_211; + } + case 6: + { + break label_216; + } + case 7: + { + break label_216; + } + case 8: + { + break label_211; + } + case 9: + { + break label_211; + } + case 10: + { + break label_211; + } + case 11: + { + break label_211; + } + case 12: + { + break label_211; + } + case 13: + { + break label_211; + } + case 14: + { + break label_211; + } + case 15: + { + break label_211; + } + case 16: + { + break label_211; + } + case 17: + { + break label_211; + } + case 18: + { + break label_213; + } + case 19: + { + break label_212; + } + case 20: + { + break label_212; + } + case 21: + { + break label_212; + } + case 22: + { + break label_212; + } + default: + { + break label_211; + } + } + } + if (((int) memory.read((int) iL[13] < 0 ? iL[13] : iL[13] + 10) & 0xFF) != 0) { + break label_212; + } + break label_211; + } + if (((int) memory.read((int) iL[13] < 0 ? iL[13] : iL[13] + 0) & 0xFF) != 0) { + break label_212; + } + break label_211; + } + if (((int) memory.read((int) iL[13] < 0 ? iL[13] : iL[13] + 6) & 0xFF) != 0) { + break label_212; + } + break label_211; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[13] < 0 ? iL[13] : iL[13] + 4) & 0xFF)) != 0) { + break label_211; + } + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[14] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 216); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 2616, (long) lL[0]); + int ciTableIdx_219 = (int) (iL[14]); + int ciFuncId_219 = instance.table(0).requiredRef(ciTableIdx_219); + com.dylibso.chicory.runtime.Instance ciRefInstance_219 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_219), instance); + if (!ciRefInstance_219.type(ciRefInstance_219.functionType(ciFuncId_219)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_219 = new long[4]; + callArgs_219[3] = ((long) (iL[4] + 2616)); + callArgs_219[2] = ((long) iL[0]); + callArgs_219[1] = ((long) iL[3]); + callArgs_219[0] = ((long) iL[13]); + long[] callResult_219 = ciRefInstance_219.getMachine().call(ciFuncId_219, callArgs_219); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_219[0])) != 0) { + break label_210; + } + iL[14] = 24928; + } + long[] callArgs_220 = new long[3]; + callArgs_220[2] = ((long) 0); + callArgs_220[1] = ((long) iL[14]); + callArgs_220[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_220); + break label_192; + } + iL[3] = (iL[3] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[3], iL[15]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_207; + } + break; + } + } + label_217: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_221 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 220)); + int ciFuncId_221 = instance.table(0).requiredRef(ciTableIdx_221); + com.dylibso.chicory.runtime.Instance ciRefInstance_221 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_221), instance); + if (!ciRefInstance_221.type(ciRefInstance_221.functionType(ciFuncId_221)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_221 = new long[1]; + callArgs_221[0] = ((long) iL[3]); + long[] callResult_221 = ciRefInstance_221.getMachine().call(ciFuncId_221, callArgs_221); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_221[0])) != 0) { + break label_217; + } + long[] callArgs_222 = new long[3]; + callArgs_222[2] = ((long) 0); + callArgs_222[1] = ((long) 20316); + callArgs_222[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_222); + break label_192; + } + iL[3] = (iL[18] + iL[17]); + label_218: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) + 27) & 0xFF)) != 0) { + break label_218; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + break label_204; + } + long[] callArgs_223 = new long[3]; + callArgs_223[2] = ((long) 1296); + callArgs_223[1] = ((long) iL[3]); + callArgs_223[0] = ((long) (iL[4] + 2936)); + long[] callResult_223 = instance.getMachine().call(804, callArgs_223); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_223[0])) != 0) { + break label_192; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948)) != 0) { + break label_204; + } + long[] callArgs_224 = new long[3]; + callArgs_224[2] = ((long) 0); + callArgs_224[1] = ((long) 15031); + callArgs_224[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_224); + break label_192; + } + long[] callArgs_225 = new long[3]; + callArgs_225[2] = ((long) 0); + callArgs_225[1] = ((long) 19775); + callArgs_225[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_225); + break label_192; + } + label_219: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_226 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 548)); + int ciFuncId_226 = instance.table(0).requiredRef(ciTableIdx_226); + com.dylibso.chicory.runtime.Instance ciRefInstance_226 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_226), instance); + if (!ciRefInstance_226.type(ciRefInstance_226.functionType(ciFuncId_226)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_226 = new long[2]; + callArgs_226[1] = ((long) iL[19]); + callArgs_226[0] = ((long) iL[3]); + long[] callResult_226 = ciRefInstance_226.getMachine().call(ciFuncId_226, callArgs_226); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_226[0])) != 0) { + break label_219; + } + long[] callArgs_227 = new long[3]; + callArgs_227[2] = ((long) 0); + callArgs_227[1] = ((long) 19049); + callArgs_227[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_227); + break label_192; + } + iL[16] = (iL[16] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[16], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3072)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_199; + } + break; + } + } + label_220: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_228 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 552)); + int ciFuncId_228 = instance.table(0).requiredRef(ciTableIdx_228); + com.dylibso.chicory.runtime.Instance ciRefInstance_228 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_228), instance); + if (!ciRefInstance_228.type(ciRefInstance_228.functionType(ciFuncId_228)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_228 = new long[1]; + callArgs_228[0] = ((long) iL[3]); + long[] callResult_228 = ciRefInstance_228.getMachine().call(ciFuncId_228, callArgs_228); + if (((int) callResult_228[0]) != 0) { + break label_220; + } + iL[3] = 0; + break label_191; + } + long[] callArgs_229 = new long[3]; + callArgs_229[2] = ((long) 0); + callArgs_229[1] = ((long) 24474); + callArgs_229[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_229); + break label_192; + } + long[] callArgs_230 = new long[3]; + callArgs_230[2] = ((long) 0); + callArgs_230[1] = ((long) 19253); + callArgs_230[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_230); + } + iL[3] = 1; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 20009; + break _hb; + } + } + label_221: { + int _d15 = func_801__h15(iL, lL, memory, instance); + if (_d15 >= 10000) { + _hs[0] = (_d15 - 10000); + break _hb; + } + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 20009; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h7(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_99: { + label_100: { + label_101: { + label_102: { + label_103: { + label_104: { + int _d12 = func_804__h12(iL, lL, memory, instance); + if (_d12 == 1) + break label_101; + if (_d12 == 2) + break label_100; + if (_d12 == 3) + break label_102; + if (_d12 == 4) + break label_99; + if (_d12 == 5) + break label_103; + if (_d12 >= 10000) { + _hs[0] = (_d12 - 10000); + break _hb; + } + } + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_145 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 232)); + int ciFuncId_145 = instance.table(0).requiredRef(ciTableIdx_145); + com.dylibso.chicory.runtime.Instance ciRefInstance_145 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_145), instance); + if (!ciRefInstance_145.type(ciRefInstance_145.functionType(ciFuncId_145)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_145 = new long[2]; + callArgs_145[1] = ((long) iL[4]); + callArgs_145[0] = ((long) iL[12]); + long[] callResult_145 = ciRefInstance_145.getMachine().call(ciFuncId_145, callArgs_145); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_145[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + long[] callArgs_146 = new long[3]; + callArgs_146[2] = ((long) 0); + callArgs_146[1] = ((long) 25792); + callArgs_146[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_146); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + label_199: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_147 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 308)); + int ciFuncId_147 = instance.table(0).requiredRef(ciTableIdx_147); + com.dylibso.chicory.runtime.Instance ciRefInstance_147 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_147), instance); + if (!ciRefInstance_147.type(ciRefInstance_147.functionType(ciFuncId_147)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_147 = new long[2]; + callArgs_147[1] = ((long) iL[4]); + callArgs_147[0] = ((long) iL[12]); + long[] callResult_147 = ciRefInstance_147.getMachine().call(ciFuncId_147, callArgs_147); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_147[0])) != 0) { + break label_199; + } + long[] callArgs_148 = new long[3]; + callArgs_148[2] = ((long) 0); + callArgs_148[1] = ((long) 20376); + callArgs_148[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_148); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_149 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_149 = instance.table(0).requiredRef(ciTableIdx_149); + com.dylibso.chicory.runtime.Instance ciRefInstance_149 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_149), instance); + if (!ciRefInstance_149.type(ciRefInstance_149.functionType(ciFuncId_149)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_149 = new long[1]; + callArgs_149[0] = ((long) iL[4]); + long[] callResult_149 = ciRefInstance_149.getMachine().call(ciFuncId_149, callArgs_149); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_149[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + long[] callArgs_150 = new long[3]; + callArgs_150[2] = ((long) 0); + callArgs_150[1] = ((long) 25128); + callArgs_150[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_150); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + label_200: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_151 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 348)); + int ciFuncId_151 = instance.table(0).requiredRef(ciTableIdx_151); + com.dylibso.chicory.runtime.Instance ciRefInstance_151 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_151), instance); + if (!ciRefInstance_151.type(ciRefInstance_151.functionType(ciFuncId_151)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_151 = new long[2]; + callArgs_151[1] = ((long) iL[4]); + callArgs_151[0] = ((long) iL[12]); + long[] callResult_151 = ciRefInstance_151.getMachine().call(ciFuncId_151, callArgs_151); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_151[0])) != 0) { + break label_200; + } + long[] callArgs_152 = new long[3]; + callArgs_152[2] = ((long) 0); + callArgs_152[1] = ((long) 22518); + callArgs_152[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_152); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_153 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_153 = instance.table(0).requiredRef(ciTableIdx_153); + com.dylibso.chicory.runtime.Instance ciRefInstance_153 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_153), instance); + if (!ciRefInstance_153.type(ciRefInstance_153.functionType(ciFuncId_153)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_153 = new long[1]; + callArgs_153[0] = ((long) iL[4]); + long[] callResult_153 = ciRefInstance_153.getMachine().call(ciFuncId_153, callArgs_153); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_153[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + long[] callArgs_154 = new long[3]; + callArgs_154[2] = ((long) 0); + callArgs_154[1] = ((long) 25128); + callArgs_154[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_154); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + label_201: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_155 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 536)); + int ciFuncId_155 = instance.table(0).requiredRef(ciTableIdx_155); + com.dylibso.chicory.runtime.Instance ciRefInstance_155 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_155), instance); + if (!ciRefInstance_155.type(ciRefInstance_155.functionType(ciFuncId_155)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_155 = new long[2]; + callArgs_155[1] = ((long) iL[4]); + callArgs_155[0] = ((long) iL[12]); + long[] callResult_155 = ciRefInstance_155.getMachine().call(ciFuncId_155, callArgs_155); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_155[0])) != 0) { + break label_201; + } + long[] callArgs_156 = new long[3]; + callArgs_156[2] = ((long) 0); + callArgs_156[1] = ((long) 20405); + callArgs_156[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_156); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_157 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_157 = instance.table(0).requiredRef(ciTableIdx_157); + com.dylibso.chicory.runtime.Instance ciRefInstance_157 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_157), instance); + if (!ciRefInstance_157.type(ciRefInstance_157.functionType(ciFuncId_157)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_157 = new long[1]; + callArgs_157[0] = ((long) iL[4]); + long[] callResult_157 = ciRefInstance_157.getMachine().call(ciFuncId_157, callArgs_157); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_157[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + long[] callArgs_158 = new long[3]; + callArgs_158[2] = ((long) 0); + callArgs_158[1] = ((long) 25128); + callArgs_158[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_158); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + label_202: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_159 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 540)); + int ciFuncId_159 = instance.table(0).requiredRef(ciTableIdx_159); + com.dylibso.chicory.runtime.Instance ciRefInstance_159 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_159), instance); + if (!ciRefInstance_159.type(ciRefInstance_159.functionType(ciFuncId_159)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_159 = new long[2]; + callArgs_159[1] = ((long) iL[4]); + callArgs_159[0] = ((long) iL[12]); + long[] callResult_159 = ciRefInstance_159.getMachine().call(ciFuncId_159, callArgs_159); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_159[0])) != 0) { + break label_202; + } + long[] callArgs_160 = new long[3]; + callArgs_160[2] = ((long) 0); + callArgs_160[1] = ((long) 20346); + callArgs_160[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_160); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_161 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_161 = instance.table(0).requiredRef(ciTableIdx_161); + com.dylibso.chicory.runtime.Instance ciRefInstance_161 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_161), instance); + if (!ciRefInstance_161.type(ciRefInstance_161.functionType(ciFuncId_161)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_161 = new long[1]; + callArgs_161[0] = ((long) iL[4]); + long[] callResult_161 = ciRefInstance_161.getMachine().call(ciFuncId_161, callArgs_161); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_161[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + long[] callArgs_162 = new long[3]; + callArgs_162[2] = ((long) 0); + callArgs_162[1] = ((long) 25128); + callArgs_162[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_162); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h8(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_356: { + label_357: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_396 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 36)); + int ciFuncId_396 = instance.table(0).requiredRef(ciTableIdx_396); + com.dylibso.chicory.runtime.Instance ciRefInstance_396 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_396), instance); + if (!ciRefInstance_396.type(ciRefInstance_396.functionType(ciFuncId_396)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_396 = new long[2]; + callArgs_396[1] = ((long) iL[0]); + callArgs_396[0] = ((long) iL[3]); + long[] callResult_396 = ciRefInstance_396.getMachine().call(ciFuncId_396, callArgs_396); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_396[0])) != 0) { + break label_357; + } + long[] callArgs_397 = new long[3]; + callArgs_397[2] = ((long) 0); + callArgs_397[1] = ((long) 24311); + callArgs_397[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_397); + break label_356; + } + label_358: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_398 = new long[3]; + callArgs_398[2] = ((long) (iL[4] + 3168)); + callArgs_398[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_398[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_398 = instance.getMachine().call(177, callArgs_398); + iL[3] = ((int) callResult_398[0]); + if (iL[3] != 0) { + break label_358; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1616, (int) 6584); + long[] callArgs_399 = new long[3]; + callArgs_399[2] = ((long) (iL[4] + 1616)); + callArgs_399[1] = ((long) 11260); + callArgs_399[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_399); + break label_356; + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_359: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[0], iL[3]) != 0) { + break label_359; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1640, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1636, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1632, (int) 6584); + long[] callArgs_400 = new long[3]; + callArgs_400[2] = ((long) (iL[4] + 1632)); + callArgs_400[1] = ((long) 12552); + callArgs_400[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_400); + break label_356; + } + label_360: { + label_361: { + label_362: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_401 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 40)); + int ciFuncId_401 = instance.table(0).requiredRef(ciTableIdx_401); + com.dylibso.chicory.runtime.Instance ciRefInstance_401 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_401), instance); + if (!ciRefInstance_401.type(ciRefInstance_401.functionType(ciFuncId_401)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_401 = new long[2]; + callArgs_401[1] = ((long) iL[0]); + callArgs_401[0] = ((long) iL[3]); + long[] callResult_401 = ciRefInstance_401.getMachine().call(ciFuncId_401, callArgs_401); + if (((int) callResult_401[0]) != 0) { + break label_362; + } + label_363: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_363; + } + iL[17] = 0; + label_364: while (true) { + label_365: { + int _d16 = func_801__h16(iL, lL, memory, instance); + if (_d16 == 1) + break label_356; + if (_d16 == 2) + break label_360; + if (_d16 == 3) + break label_361; + if (_d16 >= 10000) { + _hs[0] = (_d16 - 10000); + break _hb; + } + } + iL[17] = (iL[17] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[0], iL[17]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_364; + } + break; + } + } + label_408: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_430 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 56)); + int ciFuncId_430 = instance.table(0).requiredRef(ciTableIdx_430); + com.dylibso.chicory.runtime.Instance ciRefInstance_430 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_430), instance); + if (!ciRefInstance_430.type(ciRefInstance_430.functionType(ciFuncId_430)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_430 = new long[1]; + callArgs_430[0] = ((long) iL[3]); + long[] callResult_430 = ciRefInstance_430.getMachine().call(ciFuncId_430, callArgs_430); + if (((int) callResult_430[0]) != 0) { + break label_408; + } + iL[3] = 0; + break _hb; + } + long[] callArgs_431 = new long[3]; + callArgs_431[2] = ((long) 0); + callArgs_431[1] = ((long) 24344); + callArgs_431[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_431); + break label_356; + } + long[] callArgs_432 = new long[3]; + callArgs_432[2] = ((long) 0); + callArgs_432[1] = ((long) 19934); + callArgs_432[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_432); + break label_356; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1744, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[15], 0) != 0 ? 29327 : 38861)); + iL[3] = (iL[15] >> 31); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1748, (int) ((iL[15] ^ iL[3]) - iL[3])); + long[] callArgs_433 = new long[3]; + callArgs_433[2] = ((long) (iL[4] + 1744)); + callArgs_433[1] = ((long) 29501); + callArgs_433[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_433); + break label_356; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1696, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[15], 0) != 0 ? 29327 : 38861)); + iL[3] = (iL[15] >> 31); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1700, (int) ((iL[15] ^ iL[3]) - iL[3])); + long[] callArgs_434 = new long[3]; + callArgs_434[2] = ((long) (iL[4] + 1696)); + callArgs_434[1] = ((long) 29540); + callArgs_434[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_434); + } + iL[3] = 1; + } while (false); + return _hs[0]; + } + + private static int func_804__h8(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_81: { + label_82: { + label_83: { + label_84: { + label_85: { + int _d13 = func_804__h13(iL, lL, memory, instance); + if (_d13 == 1) + break label_84; + if (_d13 == 2) + break label_83; + if (_d13 == 3) + break label_82; + if (_d13 == 4) + break label_81; + if (_d13 >= 10000) { + _hs[0] = (_d13 - 10000); + break _hb; + } + } + iL[11] = 1; + long[] callArgs_223 = new long[3]; + callArgs_223[2] = ((long) 1782); + callArgs_223[1] = ((long) (iL[3] + 352)); + callArgs_223[0] = ((long) iL[0]); + long[] callResult_223 = instance.getMachine().call(814, callArgs_223); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_223[0])) != 0) { + { + _hs[0] = 20007; + break _hb; + } + } + label_227: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_224 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 520)); + int ciFuncId_224 = instance.table(0).requiredRef(ciTableIdx_224); + com.dylibso.chicory.runtime.Instance ciRefInstance_224 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_224), instance); + if (!ciRefInstance_224.type(ciRefInstance_224.functionType(ciFuncId_224)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_224 = new long[2]; + callArgs_224[1] = ((long) iL[12]); + callArgs_224[0] = ((long) iL[4]); + long[] callResult_224 = ciRefInstance_224.getMachine().call(ciFuncId_224, callArgs_224); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_224[0])) != 0) { + break label_227; + } + iL[4] = 20589; + { + _hs[0] = 20038; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_225 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_225 = instance.table(0).requiredRef(ciTableIdx_225); + com.dylibso.chicory.runtime.Instance ciRefInstance_225 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_225), instance); + if (!ciRefInstance_225.type(ciRefInstance_225.functionType(ciFuncId_225)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_225 = new long[2]; + callArgs_225[1] = ((long) iL[12]); + callArgs_225[0] = ((long) iL[4]); + long[] callResult_225 = ciRefInstance_225.getMachine().call(ciFuncId_225, callArgs_225); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_225[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 20038; + break _hb; + } + } + label_228: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_226 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 524)); + int ciFuncId_226 = instance.table(0).requiredRef(ciTableIdx_226); + com.dylibso.chicory.runtime.Instance ciRefInstance_226 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_226), instance); + if (!ciRefInstance_226.type(ciRefInstance_226.functionType(ciFuncId_226)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_226 = new long[1]; + callArgs_226[0] = ((long) iL[4]); + long[] callResult_226 = ciRefInstance_226.getMachine().call(ciFuncId_226, callArgs_226); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_226[0])) != 0) { + break label_228; + } + long[] callArgs_227 = new long[3]; + callArgs_227[2] = ((long) 0); + callArgs_227[1] = ((long) 22220); + callArgs_227[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_227); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_228 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_228 = instance.table(0).requiredRef(ciTableIdx_228); + com.dylibso.chicory.runtime.Instance ciRefInstance_228 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_228), instance); + if (!ciRefInstance_228.type(ciRefInstance_228.functionType(ciFuncId_228)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_228 = new long[1]; + callArgs_228[0] = ((long) iL[4]); + long[] callResult_228 = ciRefInstance_228.getMachine().call(ciFuncId_228, callArgs_228); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_228[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + long[] callArgs_229 = new long[3]; + callArgs_229[2] = ((long) 0); + callArgs_229[1] = ((long) 25128); + callArgs_229[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_229); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + label_229: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_230 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 536)); + int ciFuncId_230 = instance.table(0).requiredRef(ciTableIdx_230); + com.dylibso.chicory.runtime.Instance ciRefInstance_230 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_230), instance); + if (!ciRefInstance_230.type(ciRefInstance_230.functionType(ciFuncId_230)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_230 = new long[2]; + callArgs_230[1] = ((long) iL[4]); + callArgs_230[0] = ((long) iL[12]); + long[] callResult_230 = ciRefInstance_230.getMachine().call(ciFuncId_230, callArgs_230); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_230[0])) != 0) { + break label_229; + } + long[] callArgs_231 = new long[3]; + callArgs_231[2] = ((long) 0); + callArgs_231[1] = ((long) 20405); + callArgs_231[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_231); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_232 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_232 = instance.table(0).requiredRef(ciTableIdx_232); + com.dylibso.chicory.runtime.Instance ciRefInstance_232 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_232), instance); + if (!ciRefInstance_232.type(ciRefInstance_232.functionType(ciFuncId_232)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_232 = new long[1]; + callArgs_232[0] = ((long) iL[4]); + long[] callResult_232 = ciRefInstance_232.getMachine().call(ciFuncId_232, callArgs_232); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_232[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + long[] callArgs_233 = new long[3]; + callArgs_233[2] = ((long) 0); + callArgs_233[1] = ((long) 25128); + callArgs_233[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_233); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + label_230: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_234 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 352)); + int ciFuncId_234 = instance.table(0).requiredRef(ciTableIdx_234); + com.dylibso.chicory.runtime.Instance ciRefInstance_234 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_234), instance); + if (!ciRefInstance_234.type(ciRefInstance_234.functionType(ciFuncId_234)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_234 = new long[2]; + callArgs_234[1] = ((long) iL[4]); + callArgs_234[0] = ((long) iL[12]); + long[] callResult_234 = ciRefInstance_234.getMachine().call(ciFuncId_234, callArgs_234); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_234[0])) != 0) { + break label_230; + } + long[] callArgs_235 = new long[3]; + callArgs_235[2] = ((long) 0); + callArgs_235[1] = ((long) 20870); + callArgs_235[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_235); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_236 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_236 = instance.table(0).requiredRef(ciTableIdx_236); + com.dylibso.chicory.runtime.Instance ciRefInstance_236 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_236), instance); + if (!ciRefInstance_236.type(ciRefInstance_236.functionType(ciFuncId_236)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_236 = new long[1]; + callArgs_236[0] = ((long) iL[4]); + long[] callResult_236 = ciRefInstance_236.getMachine().call(ciFuncId_236, callArgs_236); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_236[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + long[] callArgs_237 = new long[3]; + callArgs_237[2] = ((long) 0); + callArgs_237[1] = ((long) 25128); + callArgs_237[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_237); + iL[11] = 1; + { + _hs[0] = 20007; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_238 = new long[8]; + callArgs_238[7] = ((long) 0); + callArgs_238[6] = ((long) 7214); + callArgs_238[5] = ((long) 2296); + callArgs_238[4] = ((long) 6811); + callArgs_238[3] = ((long) (iL[3] + 336)); + callArgs_238[2] = ((long) (iL[3] + 348)); + callArgs_238[1] = ((long) (iL[3] + 352)); + callArgs_238[0] = ((long) iL[0]); + long[] callResult_238 = instance.getMachine().call(827, callArgs_238); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_238[0])) != 0) { + { + _hs[0] = 20007; + break _hb; + } + } + label_231: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_239 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 304)); + int ciFuncId_239 = instance.table(0).requiredRef(ciTableIdx_239); + com.dylibso.chicory.runtime.Instance ciRefInstance_239 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_239), instance); + if (!ciRefInstance_239.type(ciRefInstance_239.functionType(ciFuncId_239)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_239 = new long[5]; + callArgs_239[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_239[3] = lL[0]; + callArgs_239[2] = ((long) iL[12]); + callArgs_239[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_239[0] = ((long) iL[4]); + long[] callResult_239 = ciRefInstance_239.getMachine().call(ciFuncId_239, callArgs_239); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_239[0])) != 0) { + break label_231; + } + long[] callArgs_240 = new long[3]; + callArgs_240[2] = ((long) 0); + callArgs_240[1] = ((long) 20524); + callArgs_240[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_240); + { + _hs[0] = 20007; + break _hb; + } + } + long[] callArgs_241 = new long[5]; + callArgs_241[4] = ((long) 0); + callArgs_241[3] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_241[2] = ((long) iL[12]); + callArgs_241[1] = lL[0]; + callArgs_241[0] = ((long) iL[0]); + long[] callResult_241 = instance.getMachine().call(829, callArgs_241); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_241[0])) != 0) { + { + _hs[0] = 20008; + break _hb; + } + } + { + _hs[0] = 20007; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h9(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_55: { + label_56: { + label_57: { + label_58: { + label_59: { + label_60: { + label_61: { + int _d0 = func_804__h0(iL, lL, memory, instance); + if (_d0 == 1) + break label_56; + if (_d0 == 2) { + _hs[0] = 1; + break _hb; + } + if (_d0 == 3) + break label_60; + if (_d0 == 4) + break label_58; + if (_d0 == 5) + break label_57; + if (_d0 == 6) + break label_59; + if (_d0 == 7) { + _hs[0] = 20001; + break _hb; + } + if (_d0 == 8) + break _hb; + if (_d0 == 9) { + _hs[0] = 20002; + break _hb; + } + if (_d0 == 10) { + _hs[0] = 20003; + break _hb; + } + if (_d0 == 11) { + _hs[0] = 20004; + break _hb; + } + if (_d0 == 12) { + _hs[0] = 20005; + break _hb; + } + if (_d0 == 13) { + _hs[0] = 20006; + break _hb; + } + if (_d0 == 14) { + _hs[0] = 20007; + break _hb; + } + if (_d0 == 15) + break label_55; + if (_d0 == 16) { + _hs[0] = 20008; + break _hb; + } + if (_d0 == 17) { + _hs[0] = 20009; + break _hb; + } + if (_d0 == 18) { + _hs[0] = 20010; + break _hb; + } + if (_d0 == 19) { + _hs[0] = 20011; + break _hb; + } + if (_d0 == 20) { + _hs[0] = 20012; + break _hb; + } + if (_d0 == 21) { + _hs[0] = 20013; + break _hb; + } + if (_d0 == 22) { + _hs[0] = 20014; + break _hb; + } + if (_d0 == 23) { + _hs[0] = 20015; + break _hb; + } + if (_d0 == 24) { + _hs[0] = 20016; + break _hb; + } + if (_d0 == 25) { + _hs[0] = 20017; + break _hb; + } + if (_d0 == 26) { + _hs[0] = 20018; + break _hb; + } + if (_d0 == 27) { + _hs[0] = 20019; + break _hb; + } + if (_d0 == 28) { + _hs[0] = 20020; + break _hb; + } + if (_d0 == 29) { + _hs[0] = 20021; + break _hb; + } + if (_d0 == 30) { + _hs[0] = 20022; + break _hb; + } + if (_d0 == 31) { + _hs[0] = 20023; + break _hb; + } + if (_d0 == 32) { + _hs[0] = 20024; + break _hb; + } + if (_d0 == 33) { + _hs[0] = 20000; + break _hb; + } + if (_d0 == 34) { + _hs[0] = 10001; + break _hb; + } + if (_d0 == 35) { + _hs[0] = 10002; + break _hb; + } + if (_d0 == 36) { + _hs[0] = 10003; + break _hb; + } + if (_d0 == 37) { + _hs[0] = 10004; + break _hb; + } + if (_d0 == 38) { + _hs[0] = 10005; + break _hb; + } + if (_d0 == 39) { + _hs[0] = 10006; + break _hb; + } + if (_d0 == 40) { + _hs[0] = 10007; + break _hb; + } + if (_d0 == 41) { + _hs[0] = 10008; + break _hb; + } + if (_d0 == 42) { + _hs[0] = 10009; + break _hb; + } + if (_d0 == 43) { + _hs[0] = 10010; + break _hb; + } + if (_d0 == 44) { + _hs[0] = 10011; + break _hb; + } + if (_d0 == 45) { + _hs[0] = 10012; + break _hb; + } + if (_d0 == 46) { + _hs[0] = 10013; + break _hb; + } + if (_d0 == 47) { + _hs[0] = 10014; + break _hb; + } + if (_d0 == 48) { + _hs[0] = 10015; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_313 = new long[3]; + callArgs_313[2] = ((long) 2118); + callArgs_313[1] = ((long) (iL[3] + 352)); + callArgs_313[0] = ((long) iL[0]); + long[] callResult_313 = instance.getMachine().call(814, callArgs_313); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_313[0])) != 0) { + { + _hs[0] = 20001; + break _hb; + } + } + label_265: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_314 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 472)); + int ciFuncId_314 = instance.table(0).requiredRef(ciTableIdx_314); + com.dylibso.chicory.runtime.Instance ciRefInstance_314 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_314), instance); + if (!ciRefInstance_314.type(ciRefInstance_314.functionType(ciFuncId_314)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_314 = new long[2]; + callArgs_314[1] = ((long) iL[12]); + callArgs_314[0] = ((long) iL[4]); + long[] callResult_314 = ciRefInstance_314.getMachine().call(ciFuncId_314, callArgs_314); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_314[0])) != 0) { + break label_265; + } + iL[4] = 22366; + { + _hs[0] = 10000; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_315 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 232)); + int ciFuncId_315 = instance.table(0).requiredRef(ciTableIdx_315); + com.dylibso.chicory.runtime.Instance ciRefInstance_315 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_315), instance); + if (!ciRefInstance_315.type(ciRefInstance_315.functionType(ciFuncId_315)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_315 = new long[2]; + callArgs_315[1] = ((long) iL[12]); + callArgs_315[0] = ((long) iL[4]); + long[] callResult_315 = ciRefInstance_315.getMachine().call(ciFuncId_315, callArgs_315); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_315[0])) != 0) { + break _hb; + } + iL[4] = 25792; + { + _hs[0] = 10000; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_316 = new long[3]; + callArgs_316[2] = ((long) 2118); + callArgs_316[1] = ((long) (iL[3] + 352)); + callArgs_316[0] = ((long) iL[0]); + long[] callResult_316 = instance.getMachine().call(814, callArgs_316); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_316[0])) != 0) { + { + _hs[0] = 20001; + break _hb; + } + } + label_266: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_317 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 476)); + int ciFuncId_317 = instance.table(0).requiredRef(ciTableIdx_317); + com.dylibso.chicory.runtime.Instance ciRefInstance_317 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_317), instance); + if (!ciRefInstance_317.type(ciRefInstance_317.functionType(ciFuncId_317)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_317 = new long[2]; + callArgs_317[1] = ((long) iL[12]); + callArgs_317[0] = ((long) iL[4]); + long[] callResult_317 = ciRefInstance_317.getMachine().call(ciFuncId_317, callArgs_317); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_317[0])) != 0) { + break label_266; + } + iL[4] = 22002; + { + _hs[0] = 2; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_318 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 232)); + int ciFuncId_318 = instance.table(0).requiredRef(ciTableIdx_318); + com.dylibso.chicory.runtime.Instance ciRefInstance_318 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_318), instance); + if (!ciRefInstance_318.type(ciRefInstance_318.functionType(ciFuncId_318)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_318 = new long[2]; + callArgs_318[1] = ((long) iL[12]); + callArgs_318[0] = ((long) iL[4]); + long[] callResult_318 = ciRefInstance_318.getMachine().call(ciFuncId_318, callArgs_318); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_318[0])) != 0) { + break _hb; + } + iL[4] = 25792; + { + _hs[0] = 2; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_319 = new long[3]; + callArgs_319[2] = ((long) 2199); + callArgs_319[1] = ((long) (iL[3] + 352)); + callArgs_319[0] = ((long) iL[0]); + long[] callResult_319 = instance.getMachine().call(814, callArgs_319); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_319[0])) != 0) { + { + _hs[0] = 20001; + break _hb; + } + } + label_267: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_320 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 480)); + int ciFuncId_320 = instance.table(0).requiredRef(ciTableIdx_320); + com.dylibso.chicory.runtime.Instance ciRefInstance_320 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_320), instance); + if (!ciRefInstance_320.type(ciRefInstance_320.functionType(ciFuncId_320)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_320 = new long[2]; + callArgs_320[1] = ((long) iL[12]); + callArgs_320[0] = ((long) iL[4]); + long[] callResult_320 = ciRefInstance_320.getMachine().call(ciFuncId_320, callArgs_320); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_320[0])) != 0) { + break label_267; + } + iL[4] = 22865; + { + _hs[0] = 3; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_321 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 232)); + int ciFuncId_321 = instance.table(0).requiredRef(ciTableIdx_321); + com.dylibso.chicory.runtime.Instance ciRefInstance_321 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_321), instance); + if (!ciRefInstance_321.type(ciRefInstance_321.functionType(ciFuncId_321)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_321 = new long[2]; + callArgs_321[1] = ((long) iL[12]); + callArgs_321[0] = ((long) iL[4]); + long[] callResult_321 = ciRefInstance_321.getMachine().call(ciFuncId_321, callArgs_321); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_321[0])) != 0) { + break _hb; + } + iL[4] = 25792; + { + _hs[0] = 3; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_322 = new long[3]; + callArgs_322[2] = ((long) 15936); + callArgs_322[1] = ((long) (iL[3] + 352)); + callArgs_322[0] = ((long) iL[0]); + long[] callResult_322 = instance.getMachine().call(818, callArgs_322); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_322[0])) != 0) { + { + _hs[0] = 20001; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 280, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 484); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 248, (long) lL[0]); + label_268: { + int ciTableIdx_323 = (int) (iL[12]); + int ciFuncId_323 = instance.table(0).requiredRef(ciTableIdx_323); + com.dylibso.chicory.runtime.Instance ciRefInstance_323 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_323), instance); + if (!ciRefInstance_323.type(ciRefInstance_323.functionType(ciFuncId_323)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_323 = new long[2]; + callArgs_323[1] = ((long) (iL[3] + 248)); + callArgs_323[0] = ((long) iL[4]); + long[] callResult_323 = ciRefInstance_323.getMachine().call(ciFuncId_323, callArgs_323); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_323[0])) != 0) { + break label_268; + } + iL[4] = 21939; + { + _hs[0] = 4; + break _hb; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 272, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 276); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 240, (long) lL[0]); + int ciTableIdx_324 = (int) (iL[12]); + int ciFuncId_324 = instance.table(0).requiredRef(ciTableIdx_324); + com.dylibso.chicory.runtime.Instance ciRefInstance_324 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_324), instance); + if (!ciRefInstance_324.type(ciRefInstance_324.functionType(ciFuncId_324)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_324 = new long[2]; + callArgs_324[1] = ((long) (iL[3] + 240)); + callArgs_324[0] = ((long) iL[4]); + long[] callResult_324 = ciRefInstance_324.getMachine().call(ciFuncId_324, callArgs_324); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_324[0])) != 0) { + break _hb; + } + iL[4] = 25278; + { + _hs[0] = 4; + break _hb; + } + } + label_269: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_325 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 488)); + int ciFuncId_325 = instance.table(0).requiredRef(ciTableIdx_325); + com.dylibso.chicory.runtime.Instance ciRefInstance_325 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_325), instance); + if (!ciRefInstance_325.type(ciRefInstance_325.functionType(ciFuncId_325)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_325 = new long[1]; + callArgs_325[0] = ((long) iL[4]); + long[] callResult_325 = ciRefInstance_325.getMachine().call(ciFuncId_325, callArgs_325); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_325[0])) != 0) { + break label_269; + } + long[] callArgs_326 = new long[3]; + callArgs_326[2] = ((long) 0); + callArgs_326[1] = ((long) 21907); + callArgs_326[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_326); + iL[11] = 1; + { + _hs[0] = 20001; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_327 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_327 = instance.table(0).requiredRef(ciTableIdx_327); + com.dylibso.chicory.runtime.Instance ciRefInstance_327 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_327), instance); + if (!ciRefInstance_327.type(ciRefInstance_327.functionType(ciFuncId_327)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_327 = new long[1]; + callArgs_327[0] = ((long) iL[4]); + long[] callResult_327 = ciRefInstance_327.getMachine().call(ciFuncId_327, callArgs_327); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_327[0])) != 0) { + break _hb; + } + long[] callArgs_328 = new long[3]; + callArgs_328[2] = ((long) 0); + callArgs_328[1] = ((long) 25128); + callArgs_328[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_328); + iL[11] = 1; + { + _hs[0] = 20001; + break _hb; + } + } + label_270: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_329 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 336)); + int ciFuncId_329 = instance.table(0).requiredRef(ciTableIdx_329); + com.dylibso.chicory.runtime.Instance ciRefInstance_329 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_329), instance); + if (!ciRefInstance_329.type(ciRefInstance_329.functionType(ciFuncId_329)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_329 = new long[1]; + callArgs_329[0] = ((long) iL[4]); + long[] callResult_329 = ciRefInstance_329.getMachine().call(ciFuncId_329, callArgs_329); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_329[0])) != 0) { + break label_270; + } + long[] callArgs_330 = new long[3]; + callArgs_330[2] = ((long) 0); + callArgs_330[1] = ((long) 22251); + callArgs_330[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_330); + iL[11] = 1; + { + _hs[0] = 20001; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_331 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_331 = instance.table(0).requiredRef(ciTableIdx_331); + com.dylibso.chicory.runtime.Instance ciRefInstance_331 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_331), instance); + if (!ciRefInstance_331.type(ciRefInstance_331.functionType(ciFuncId_331)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_331 = new long[1]; + callArgs_331[0] = ((long) iL[4]); + long[] callResult_331 = ciRefInstance_331.getMachine().call(ciFuncId_331, callArgs_331); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_331[0])) != 0) { + break _hb; + } + long[] callArgs_332 = new long[3]; + callArgs_332[2] = ((long) 0); + callArgs_332[1] = ((long) 25128); + callArgs_332[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_332); + iL[11] = 1; + { + _hs[0] = 20001; + break _hb; + } + } + long[] callArgs_333 = new long[1]; + callArgs_333[0] = ((long) (iL[3] + 456)); + instance.getMachine().call(831, callArgs_333); + } while (false); + return _hs[0]; + } + + private static int func_51__h4(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_58: { + label_59: { + label_60: { + label_61: { + label_62: { + label_63: { + label_64: { + label_65: { + label_66: { + switch(memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 32)) { + case 0: + { + break label_66; + } + case 1: + { + break label_65; + } + case 2: + { + break label_64; + } + case 3: + { + break label_63; + } + case 4: + { + break label_60; + } + case 5: + { + break label_61; + } + case 6: + { + break label_62; + } + case 7: + { + break label_59; + } + case 8: + { + break label_58; + } + case 9: + { + break _hb; + } + case 10: + { + { + _hs[0] = 1; + break _hb; + } + } + case 11: + { + { + _hs[0] = 2; + break _hb; + } + } + case 12: + { + { + _hs[0] = 3; + break _hb; + } + } + case 13: + { + { + _hs[0] = 4; + break _hb; + } + } + case 14: + { + { + _hs[0] = 5; + break _hb; + } + } + case 15: + { + { + _hs[0] = 30001; + break _hb; + } + } + case 16: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 17: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 18: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 19: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 20: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 21: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 22: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 23: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 24: + { + { + _hs[0] = 10008; + break _hb; + } + } + case 25: + { + { + _hs[0] = 10009; + break _hb; + } + } + case 26: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 27: + { + { + _hs[0] = 20001; + break _hb; + } + } + case 28: + { + { + _hs[0] = 20002; + break _hb; + } + } + case 29: + { + { + _hs[0] = 20003; + break _hb; + } + } + case 30: + { + { + _hs[0] = 20004; + break _hb; + } + } + case 31: + { + { + _hs[0] = 20005; + break _hb; + } + } + case 32: + { + { + _hs[0] = 20006; + break _hb; + } + } + case 33: + { + { + _hs[0] = 20007; + break _hb; + } + } + case 34: + { + { + _hs[0] = 30002; + break _hb; + } + } + case 35: + { + { + _hs[0] = 30003; + break _hb; + } + } + case 36: + { + { + _hs[0] = 30004; + break _hb; + } + } + case 37: + { + { + _hs[0] = 30005; + break _hb; + } + } + case 38: + { + { + _hs[0] = 30006; + break _hb; + } + } + case 39: + { + { + _hs[0] = 30007; + break _hb; + } + } + case 40: + { + { + _hs[0] = 6; + break _hb; + } + } + case 41: + { + { + _hs[0] = 7; + break _hb; + } + } + case 42: + { + { + _hs[0] = 30008; + break _hb; + } + } + case 43: + { + { + _hs[0] = 30009; + break _hb; + } + } + case 44: + { + { + _hs[0] = 30010; + break _hb; + } + } + case 45: + { + { + _hs[0] = 30011; + break _hb; + } + } + case 46: + { + { + _hs[0] = 30012; + break _hb; + } + } + case 47: + { + { + _hs[0] = 30013; + break _hb; + } + } + case 48: + { + { + _hs[0] = 30014; + break _hb; + } + } + case 49: + { + { + _hs[0] = 30015; + break _hb; + } + } + case 50: + { + { + _hs[0] = 20008; + break _hb; + } + } + case 51: + { + { + _hs[0] = 20009; + break _hb; + } + } + case 52: + { + { + _hs[0] = 20010; + break _hb; + } + } + case 53: + { + { + _hs[0] = 20011; + break _hb; + } + } + case 54: + { + { + _hs[0] = 20012; + break _hb; + } + } + case 55: + { + { + _hs[0] = 20013; + break _hb; + } + } + case 56: + { + { + _hs[0] = 20014; + break _hb; + } + } + case 57: + { + { + _hs[0] = 30000; + break _hb; + } + } + case 58: + { + { + _hs[0] = 30016; + break _hb; + } + } + case 59: + { + { + _hs[0] = 30017; + break _hb; + } + } + case 60: + { + { + _hs[0] = 30018; + break _hb; + } + } + case 61: + { + { + _hs[0] = 30019; + break _hb; + } + } + case 62: + { + { + _hs[0] = 30020; + break _hb; + } + } + case 63: + { + { + _hs[0] = 30021; + break _hb; + } + } + case 64: + { + { + _hs[0] = 30022; + break _hb; + } + } + default: + { + { + _hs[0] = 30023; + break _hb; + } + } + } + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) iL[2]); + callArgs_0[0] = ((long) iL[0]); + instance.getMachine().call(56, callArgs_0); + { + _hs[0] = 30023; + break _hb; + } + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) iL[2]); + callArgs_1[0] = ((long) iL[0]); + instance.getMachine().call(57, callArgs_1); + { + _hs[0] = 30023; + break _hb; + } + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) iL[2]); + callArgs_2[0] = ((long) iL[0]); + instance.getMachine().call(58, callArgs_2); + { + _hs[0] = 30023; + break _hb; + } + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) iL[2]); + callArgs_3[0] = ((long) iL[0]); + instance.getMachine().call(59, callArgs_3); + { + _hs[0] = 30023; + break _hb; + } + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) iL[2]); + callArgs_4[0] = ((long) iL[0]); + instance.getMachine().call(60, callArgs_4); + { + _hs[0] = 30023; + break _hb; + } + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) 478); + callArgs_5[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_5); + long[] callArgs_6 = new long[3]; + callArgs_6[2] = ((long) 13430); + callArgs_6[1] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)); + callArgs_6[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_6); + { + _hs[0] = 30023; + break _hb; + } + } + long[] callArgs_7 = new long[2]; + callArgs_7[1] = ((long) iL[2]); + callArgs_7[0] = ((long) iL[0]); + instance.getMachine().call(61, callArgs_7); + { + _hs[0] = 30023; + break _hb; + } + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 36)); + callArgs_8[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_8); + { + _hs[0] = 30023; + break _hb; + } + } + long[] callArgs_9 = new long[2]; + callArgs_9[1] = ((long) 2); + callArgs_9[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_9); + long[] callArgs_10 = new long[2]; + callArgs_10[1] = ((long) (iL[2] + 48)); + callArgs_10[0] = ((long) iL[0]); + instance.getMachine().call(62, callArgs_10); + long[] callArgs_11 = new long[3]; + callArgs_11[2] = ((long) (iL[2] + 152)); + callArgs_11[1] = ((long) iL[1]); + callArgs_11[0] = ((long) iL[0]); + instance.getMachine().call(55, callArgs_11); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) 11); + callArgs_12[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_12); + { + _hs[0] = 30023; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_450__h4(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_61: { + label_62: { + label_63: { + label_64: { + label_65: { + label_66: { + label_67: { + switch(memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 32)) { + case 0: + { + break label_67; + } + case 1: + { + break label_65; + } + case 2: + { + break label_64; + } + case 3: + { + break label_66; + } + case 4: + { + break label_61; + } + case 5: + { + break label_62; + } + case 6: + { + break label_63; + } + case 7: + { + break _hb; + } + case 8: + { + { + _hs[0] = 1; + break _hb; + } + } + case 9: + { + { + _hs[0] = 2; + break _hb; + } + } + case 10: + { + { + _hs[0] = 3; + break _hb; + } + } + case 11: + { + { + _hs[0] = 4; + break _hb; + } + } + case 12: + { + { + _hs[0] = 5; + break _hb; + } + } + case 13: + { + { + _hs[0] = 6; + break _hb; + } + } + case 14: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 15: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 16: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 17: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 18: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 19: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 20: + { + { + _hs[0] = 10006; + break _hb; + } + } + case 21: + { + { + _hs[0] = 10007; + break _hb; + } + } + case 22: + { + { + _hs[0] = 10008; + break _hb; + } + } + case 23: + { + { + _hs[0] = 10009; + break _hb; + } + } + case 24: + { + { + _hs[0] = 20001; + break _hb; + } + } + case 25: + { + { + _hs[0] = 20002; + break _hb; + } + } + case 26: + { + { + _hs[0] = 20003; + break _hb; + } + } + case 27: + { + { + _hs[0] = 20004; + break _hb; + } + } + case 28: + { + { + _hs[0] = 20005; + break _hb; + } + } + case 29: + { + { + _hs[0] = 20006; + break _hb; + } + } + case 30: + { + { + _hs[0] = 20007; + break _hb; + } + } + case 31: + { + { + _hs[0] = 20008; + break _hb; + } + } + case 32: + { + { + _hs[0] = 20009; + break _hb; + } + } + case 33: + { + { + _hs[0] = 20010; + break _hb; + } + } + case 34: + { + { + _hs[0] = 30001; + break _hb; + } + } + case 35: + { + { + _hs[0] = 30002; + break _hb; + } + } + case 36: + { + { + _hs[0] = 30003; + break _hb; + } + } + case 37: + { + { + _hs[0] = 30004; + break _hb; + } + } + case 38: + { + { + _hs[0] = 30005; + break _hb; + } + } + case 39: + { + { + _hs[0] = 30006; + break _hb; + } + } + case 40: + { + { + _hs[0] = 30007; + break _hb; + } + } + case 41: + { + { + _hs[0] = 30008; + break _hb; + } + } + case 42: + { + { + _hs[0] = 30009; + break _hb; + } + } + case 43: + { + { + _hs[0] = 30010; + break _hb; + } + } + case 44: + { + { + _hs[0] = 30011; + break _hb; + } + } + case 45: + { + { + _hs[0] = 30012; + break _hb; + } + } + case 46: + { + { + _hs[0] = 30013; + break _hb; + } + } + case 47: + { + { + _hs[0] = 10010; + break _hb; + } + } + case 48: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 49: + { + { + _hs[0] = 30014; + break _hb; + } + } + case 50: + { + { + _hs[0] = 20011; + break _hb; + } + } + case 51: + { + { + _hs[0] = 20012; + break _hb; + } + } + case 52: + { + { + _hs[0] = 20013; + break _hb; + } + } + case 53: + { + { + _hs[0] = 20014; + break _hb; + } + } + case 54: + { + { + _hs[0] = 30000; + break _hb; + } + } + case 55: + { + { + _hs[0] = 30015; + break _hb; + } + } + case 56: + { + { + _hs[0] = 20015; + break _hb; + } + } + case 57: + { + { + _hs[0] = 30016; + break _hb; + } + } + case 58: + { + { + _hs[0] = 30017; + break _hb; + } + } + case 59: + { + { + _hs[0] = 30018; + break _hb; + } + } + case 60: + { + { + _hs[0] = 30019; + break _hb; + } + } + case 61: + { + { + _hs[0] = 30020; + break _hb; + } + } + case 62: + { + { + _hs[0] = 30021; + break _hb; + } + } + case 63: + { + { + _hs[0] = 30022; + break _hb; + } + } + case 64: + { + { + _hs[0] = 30023; + break _hb; + } + } + default: + { + { + _hs[0] = 30024; + break _hb; + } + } + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_0 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 256)); + int ciFuncId_0 = instance.table(0).requiredRef(ciTableIdx_0); + com.dylibso.chicory.runtime.Instance ciRefInstance_0 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_0), instance); + if (!ciRefInstance_0.type(ciRefInstance_0.functionType(ciFuncId_0)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_0 = new long[2]; + callArgs_0[1] = ((long) iL[1]); + callArgs_0[0] = ((long) iL[0]); + long[] callResult_0 = ciRefInstance_0.getMachine().call(ciFuncId_0, callArgs_0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_0[0])) != 0) { + { + _hs[0] = 30024; + break _hb; + } + } + { + _hs[0] = 30025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_1 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 260)); + int ciFuncId_1 = instance.table(0).requiredRef(ciTableIdx_1); + com.dylibso.chicory.runtime.Instance ciRefInstance_1 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_1), instance); + if (!ciRefInstance_1.type(ciRefInstance_1.functionType(ciFuncId_1)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) iL[1]); + callArgs_1[0] = ((long) iL[0]); + long[] callResult_1 = ciRefInstance_1.getMachine().call(ciFuncId_1, callArgs_1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_1[0])) != 0) { + { + _hs[0] = 30024; + break _hb; + } + } + { + _hs[0] = 30025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_2 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 264)); + int ciFuncId_2 = instance.table(0).requiredRef(ciTableIdx_2); + com.dylibso.chicory.runtime.Instance ciRefInstance_2 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_2), instance); + if (!ciRefInstance_2.type(ciRefInstance_2.functionType(ciFuncId_2)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_2 = new long[2]; + callArgs_2[1] = ((long) iL[1]); + callArgs_2[0] = ((long) iL[0]); + long[] callResult_2 = ciRefInstance_2.getMachine().call(ciFuncId_2, callArgs_2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_2[0])) != 0) { + { + _hs[0] = 30024; + break _hb; + } + } + { + _hs[0] = 30025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 268)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[2]; + callArgs_3[1] = ((long) iL[1]); + callArgs_3[0] = ((long) iL[0]); + long[] callResult_3 = ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_3[0])) != 0) { + { + _hs[0] = 30024; + break _hb; + } + } + { + _hs[0] = 30025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_4 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 244)); + int ciFuncId_4 = instance.table(0).requiredRef(ciTableIdx_4); + com.dylibso.chicory.runtime.Instance ciRefInstance_4 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_4), instance); + if (!ciRefInstance_4.type(ciRefInstance_4.functionType(ciFuncId_4)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_4 = new long[2]; + callArgs_4[1] = ((long) iL[1]); + callArgs_4[0] = ((long) iL[0]); + long[] callResult_4 = ciRefInstance_4.getMachine().call(ciFuncId_4, callArgs_4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_4[0])) != 0) { + { + _hs[0] = 30024; + break _hb; + } + } + { + _hs[0] = 30025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 248)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[2]; + callArgs_5[1] = ((long) iL[1]); + callArgs_5[0] = ((long) iL[0]); + long[] callResult_5 = ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_5[0])) != 0) { + { + _hs[0] = 30024; + break _hb; + } + } + { + _hs[0] = 30025; + break _hb; + } + } + iL[2] = 1; + iL[0] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + int ciTableIdx_6 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 252)); + int ciFuncId_6 = instance.table(0).requiredRef(ciTableIdx_6); + com.dylibso.chicory.runtime.Instance ciRefInstance_6 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_6), instance); + if (!ciRefInstance_6.type(ciRefInstance_6.functionType(ciFuncId_6)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_6 = new long[2]; + callArgs_6[1] = ((long) iL[1]); + callArgs_6[0] = ((long) iL[0]); + long[] callResult_6 = ciRefInstance_6.getMachine().call(ciFuncId_6, callArgs_6); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_6[0])) != 0) { + { + _hs[0] = 30024; + break _hb; + } + } + { + _hs[0] = 30025; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h9(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_66: { + label_67: { + int _d17 = func_801__h17(iL, lL, memory, instance); + if (_d17 == 1) + break label_66; + if (_d17 >= 10000) { + _hs[0] = (_d17 - 10000); + break _hb; + } + } + label_114: { + switch((iL[17] + -6)) { + case 0: + { + { + _hs[0] = 20005; + break _hb; + } + } + case 1: + { + { + _hs[0] = 20004; + break _hb; + } + } + case 2: + { + break label_114; + } + default: + { + { + _hs[0] = 20004; + break _hb; + } + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I64_NE(3471830484708522340L, memory.readLong((int) iL[18] < 0 ? iL[18] : iL[18] + 0)) != 0) { + { + _hs[0] = 20004; + break _hb; + } + } + label_115: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_94 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 740)); + int ciFuncId_94 = instance.table(0).requiredRef(ciTableIdx_94); + com.dylibso.chicory.runtime.Instance ciRefInstance_94 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_94), instance); + if (!ciRefInstance_94.type(ciRefInstance_94.functionType(ciFuncId_94)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_94 = new long[2]; + callArgs_94[1] = ((long) iL[0]); + callArgs_94[0] = ((long) iL[3]); + long[] callResult_94 = ciRefInstance_94.getMachine().call(ciFuncId_94, callArgs_94); + if (((int) callResult_94[0]) != 0) { + break label_115; + } + label_116: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[3], iL[0]) != 0) { + break label_116; + } + label_117: while (true) { + label_118: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_95 = new long[3]; + callArgs_95[2] = ((long) (iL[4] + 3216)); + callArgs_95[1] = ((long) (iL[13] + iL[0])); + callArgs_95[0] = ((long) (iL[13] + iL[3])); + long[] callResult_95 = instance.getMachine().call(177, callArgs_95); + iL[0] = ((int) callResult_95[0]); + if (iL[0] != 0) { + break label_118; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1312, (int) 16363); + long[] callArgs_96 = new long[3]; + callArgs_96[2] = ((long) (iL[4] + 1312)); + callArgs_96[1] = ((long) 11260); + callArgs_96[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_96); + { + _hs[0] = 30002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_119: { + long[] callArgs_97 = new long[3]; + callArgs_97[2] = ((long) (iL[4] + 3168)); + callArgs_97[1] = ((long) (iL[3] + iL[13])); + callArgs_97[0] = ((long) (iL[3] + iL[0])); + long[] callResult_97 = instance.getMachine().call(177, callArgs_97); + iL[3] = ((int) callResult_97[0]); + if (iL[3] != 0) { + break label_119; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1328, (int) 14996); + long[] callArgs_98 = new long[3]; + callArgs_98[2] = ((long) (iL[4] + 1328)); + callArgs_98[1] = ((long) 11260); + callArgs_98[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_98); + { + _hs[0] = 30002; + break _hb; + } + } + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_120: { + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168) + iL[13]); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_120; + } + long[] callArgs_99 = new long[3]; + callArgs_99[2] = ((long) 0); + callArgs_99[1] = ((long) 17707); + callArgs_99[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_99); + { + _hs[0] = 30002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[3]); + label_121: { + label_122: { + label_123: { + int _d18 = func_801__h18(iL, lL, memory, instance); + if (_d18 == 1) + break label_122; + if (_d18 == 2) + break label_121; + if (_d18 >= 10000) { + _hs[0] = (_d18 - 10000); + break _hb; + } + } + long[] callArgs_135 = new long[3]; + callArgs_135[2] = ((long) 0); + callArgs_135[1] = ((long) 19385); + callArgs_135[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_135); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + } + label_145: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948)) != 0) { + break label_145; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1344, (int) iL[3]); + long[] callArgs_136 = new long[3]; + callArgs_136[2] = ((long) (iL[4] + 1344)); + callArgs_136[1] = ((long) 29336); + callArgs_136[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_136); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[3], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_117; + } + break; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_137 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 772)); + int ciFuncId_137 = instance.table(0).requiredRef(ciTableIdx_137); + com.dylibso.chicory.runtime.Instance ciRefInstance_137 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_137), instance); + if (!ciRefInstance_137.type(ciRefInstance_137.functionType(ciFuncId_137)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_137 = new long[1]; + callArgs_137[0] = ((long) iL[3]); + long[] callResult_137 = ciRefInstance_137.getMachine().call(ciFuncId_137, callArgs_137); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_137[0])) != 0) { + { + _hs[0] = 30004; + break _hb; + } + } + long[] callArgs_138 = new long[3]; + callArgs_138[2] = ((long) 0); + callArgs_138[1] = ((long) 24146); + callArgs_138[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_138); + { + _hs[0] = 30002; + break _hb; + } + } + long[] callArgs_139 = new long[3]; + callArgs_139[2] = ((long) 0); + callArgs_139[1] = ((long) 24111); + callArgs_139[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_139); + { + _hs[0] = 30002; + break _hb; + } + } + long[] callArgs_140 = new long[3]; + callArgs_140[2] = ((long) 0); + callArgs_140[1] = ((long) 19962); + callArgs_140[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_140); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h10(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_125: { + label_126: { + label_127: { + label_128: { + int _d15 = func_804__h15(iL, lL, memory, instance); + if (_d15 == 1) + break label_125; + if (_d15 == 2) + break label_127; + if (_d15 == 3) + break label_126; + if (_d15 >= 10000) { + _hs[0] = (_d15 - 10000); + break _hb; + } + } + iL[11] = 1; + long[] callArgs_49 = new long[3]; + callArgs_49[2] = ((long) 14198); + callArgs_49[1] = ((long) (iL[3] + 352)); + callArgs_49[0] = ((long) iL[0]); + long[] callResult_49 = instance.getMachine().call(814, callArgs_49); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_49[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_158: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_50 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 320)); + int ciFuncId_50 = instance.table(0).requiredRef(ciTableIdx_50); + com.dylibso.chicory.runtime.Instance ciRefInstance_50 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_50), instance); + if (!ciRefInstance_50.type(ciRefInstance_50.functionType(ciFuncId_50)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_50 = new long[2]; + callArgs_50[1] = ((long) iL[12]); + callArgs_50[0] = ((long) iL[4]); + long[] callResult_50 = ciRefInstance_50.getMachine().call(ciFuncId_50, callArgs_50); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_50[0])) != 0) { + break label_158; + } + iL[4] = 22281; + { + _hs[0] = 30014; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_51 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_51 = instance.table(0).requiredRef(ciTableIdx_51); + com.dylibso.chicory.runtime.Instance ciRefInstance_51 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_51), instance); + if (!ciRefInstance_51.type(ciRefInstance_51.functionType(ciFuncId_51)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_51 = new long[2]; + callArgs_51[1] = ((long) iL[12]); + callArgs_51[0] = ((long) iL[4]); + long[] callResult_51 = ciRefInstance_51.getMachine().call(ciFuncId_51, callArgs_51); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_51[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 30014; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_52 = new long[3]; + callArgs_52[2] = ((long) 6298); + callArgs_52[1] = ((long) (iL[3] + 336)); + callArgs_52[0] = ((long) iL[0]); + long[] callResult_52 = instance.getMachine().call(813, callArgs_52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_52[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + long[] callArgs_53 = new long[2]; + callArgs_53[1] = ((long) iL[13]); + callArgs_53[0] = ((long) iL[6]); + instance.getMachine().call(822, callArgs_53); + label_159: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_159; + } + iL[12] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12); + iL[4] = 0; + iL[14] = iL[13]; + label_160: while (true) { + label_161: { + iL[10] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 4); + long[] callArgs_54 = new long[3]; + callArgs_54[2] = ((long) (iL[3] + 352)); + callArgs_54[1] = ((long) (iL[10] + memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0))); + callArgs_54[0] = ((long) (iL[10] + iL[12])); + long[] callResult_54 = instance.getMachine().call(177, callArgs_54); + iL[12] = ((int) callResult_54[0]); + if (iL[12] != 0) { + break label_161; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 112, (int) 14105); + long[] callArgs_55 = new long[3]; + callArgs_55[2] = ((long) (iL[3] + 112)); + callArgs_55[1] = ((long) 11260); + callArgs_55[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_55); + { + _hs[0] = 30007; + break _hb; + } + } + iL[12] = (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12) + iL[12]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (int) iL[12]); + memory.writeI32((int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 76) + iL[4]) < 0 ? (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 76) + iL[4]) : (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 76) + iL[4]) + 0, (int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352)); + iL[4] = (iL[4] + 4); + iL[14] = (iL[14] + -1); + if (iL[14] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_160; + } + break; + } + } + iL[11] = 1; + long[] callArgs_56 = new long[3]; + callArgs_56[2] = ((long) 14075); + callArgs_56[1] = ((long) (iL[3] + 352)); + callArgs_56[0] = ((long) iL[0]); + long[] callResult_56 = instance.getMachine().call(814, callArgs_56); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_56[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_57 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 324)); + int ciFuncId_57 = instance.table(0).requiredRef(ciTableIdx_57); + com.dylibso.chicory.runtime.Instance ciRefInstance_57 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_57), instance); + if (!ciRefInstance_57.type(ciRefInstance_57.functionType(ciFuncId_57)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_57 = new long[4]; + callArgs_57[3] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352)); + callArgs_57[2] = ((long) (iL[13] != 0 ? memory.readInt((int) iL[6] < 0 ? iL[6] : iL[6] + 0) : 0)); + callArgs_57[1] = ((long) iL[13]); + callArgs_57[0] = ((long) iL[4]); + long[] callResult_57 = ciRefInstance_57.getMachine().call(ciFuncId_57, callArgs_57); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_57[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + long[] callArgs_58 = new long[3]; + callArgs_58[2] = ((long) 0); + callArgs_58[1] = ((long) 22684); + callArgs_58[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_58); + { + _hs[0] = 30007; + break _hb; + } + } + label_162: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_59 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 500)); + int ciFuncId_59 = instance.table(0).requiredRef(ciTableIdx_59); + com.dylibso.chicory.runtime.Instance ciRefInstance_59 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_59), instance); + if (!ciRefInstance_59.type(ciRefInstance_59.functionType(ciFuncId_59)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_59 = new long[1]; + callArgs_59[0] = ((long) iL[4]); + long[] callResult_59 = ciRefInstance_59.getMachine().call(ciFuncId_59, callArgs_59); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_59[0])) != 0) { + break label_162; + } + long[] callArgs_60 = new long[3]; + callArgs_60[2] = ((long) 0); + callArgs_60[1] = ((long) 21820); + callArgs_60[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_60); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_61 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_61 = instance.table(0).requiredRef(ciTableIdx_61); + com.dylibso.chicory.runtime.Instance ciRefInstance_61 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_61), instance); + if (!ciRefInstance_61.type(ciRefInstance_61.functionType(ciFuncId_61)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_61 = new long[1]; + callArgs_61[0] = ((long) iL[4]); + long[] callResult_61 = ciRefInstance_61.getMachine().call(ciFuncId_61, callArgs_61); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_61[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + long[] callArgs_62 = new long[3]; + callArgs_62[2] = ((long) 0); + callArgs_62[1] = ((long) 25128); + callArgs_62[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_62); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + label_163: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_63 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 492)); + int ciFuncId_63 = instance.table(0).requiredRef(ciTableIdx_63); + com.dylibso.chicory.runtime.Instance ciRefInstance_63 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_63), instance); + if (!ciRefInstance_63.type(ciRefInstance_63.functionType(ciFuncId_63)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_63 = new long[1]; + callArgs_63[0] = ((long) iL[4]); + long[] callResult_63 = ciRefInstance_63.getMachine().call(ciFuncId_63, callArgs_63); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_63[0])) != 0) { + break label_163; + } + long[] callArgs_64 = new long[3]; + callArgs_64[2] = ((long) 0); + callArgs_64[1] = ((long) 21694); + callArgs_64[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_64); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_65 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_65 = instance.table(0).requiredRef(ciTableIdx_65); + com.dylibso.chicory.runtime.Instance ciRefInstance_65 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_65), instance); + if (!ciRefInstance_65.type(ciRefInstance_65.functionType(ciFuncId_65)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_65 = new long[1]; + callArgs_65[0] = ((long) iL[4]); + long[] callResult_65 = ciRefInstance_65.getMachine().call(ciFuncId_65, callArgs_65); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_65[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + long[] callArgs_66 = new long[3]; + callArgs_66[2] = ((long) 0); + callArgs_66[1] = ((long) 25128); + callArgs_66[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_66); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1176__h6(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_56: { + label_57: { + label_58: { + label_59: { + int _d7 = func_1176__h7(iL, memory, instance); + if (_d7 == 1) + break label_58; + if (_d7 == 2) + break label_57; + if (_d7 == 3) + break label_56; + if (_d7 >= 10000) { + _hs[0] = (_d7 - 10000); + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 30019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) (iL[2] + 16) < 0 ? (iL[2] + 16) : (iL[2] + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) (iL[2] + 8) < 0 ? (iL[2] + 8) : (iL[2] + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 0, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_17 = new long[3]; + callArgs_17[2] = ((long) iL[1]); + callArgs_17[1] = ((long) iL[2]); + callArgs_17[0] = ((long) iL[0]); + long[] callResult_17 = instance.getMachine().call(1260, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_17[0])) != 0) { + { + _hs[0] = 30020; + break _hb; + } + } + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 30019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + memory.writeI32((int) ((iL[2] + 24) + 16) < 0 ? ((iL[2] + 24) + 16) : ((iL[2] + 24) + 16) + 0, (int) memory.readInt((int) ((iL[2] + 1688) + 16) < 0 ? ((iL[2] + 1688) + 16) : ((iL[2] + 1688) + 16) + 0)); + memory.writeLong((int) ((iL[2] + 24) + 8) < 0 ? ((iL[2] + 24) + 8) : ((iL[2] + 24) + 8) + 0, (long) memory.readLong((int) ((iL[2] + 1688) + 8) < 0 ? ((iL[2] + 1688) + 8) : ((iL[2] + 1688) + 8) + 0)); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 24, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + long[] callArgs_18 = new long[3]; + callArgs_18[2] = ((long) iL[1]); + callArgs_18[1] = ((long) (iL[2] + 24)); + callArgs_18[0] = ((long) iL[0]); + long[] callResult_18 = instance.getMachine().call(1261, callArgs_18); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_18[0])) != 0) { + { + _hs[0] = 30020; + break _hb; + } + } + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[4] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 30019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + iL[5] = 1; + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[4] ^ 1))); + label_67: { + long[] callArgs_19 = new long[1]; + callArgs_19[0] = ((long) (iL[2] + 1688)); + long[] callResult_19 = instance.getMachine().call(1262, callArgs_19); + iL[3] = ((int) callResult_19[0]); + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) (iL[3] + 36)); + callArgs_20[0] = ((long) iL[0]); + long[] callResult_20 = instance.getMachine().call(1184, callArgs_20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_20[0])) != 0) { + break label_67; + } + iL[0] = (iL[3] + 40); + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + -36)); + callArgs_21[0] = ((long) (iL[3] + 48)); + long[] callResult_21 = instance.getMachine().call(160, callArgs_21); + long[] callArgs_22 = new long[1]; + callArgs_22[0] = ((long) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + -36)); + long[] callResult_22 = instance.getMachine().call(162, callArgs_22); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) ((int) callResult_22[0])); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + { + _hs[0] = 30020; + break _hb; + } + } + int ciTableIdx_23 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_23 = instance.table(0).requiredRef(ciTableIdx_23); + com.dylibso.chicory.runtime.Instance ciRefInstance_23 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_23), instance); + if (!ciRefInstance_23.type(ciRefInstance_23.functionType(ciFuncId_23)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_23 = new long[1]; + callArgs_23[0] = ((long) iL[0]); + ciRefInstance_23.getMachine().call(ciFuncId_23, callArgs_23); + { + _hs[0] = 30020; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + int ciTableIdx_24 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_24 = instance.table(0).requiredRef(ciTableIdx_24); + com.dylibso.chicory.runtime.Instance ciRefInstance_24 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_24), instance); + if (!ciRefInstance_24.type(ciRefInstance_24.functionType(ciFuncId_24)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_24 = new long[1]; + callArgs_24[0] = ((long) iL[3]); + ciRefInstance_24.getMachine().call(ciFuncId_24, callArgs_24); + { + _hs[0] = 30008; + break _hb; + } + } + iL[0] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[0] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 30019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (byte) ((iL[0] ^ 1))); + long[] callArgs_25 = new long[1]; + callArgs_25[0] = ((long) 36); + long[] callResult_25 = instance.getMachine().call(1776, callArgs_25); + iL[0] = ((int) callResult_25[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 39); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 52324); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) (iL[2] + 1696) < 0 ? (iL[2] + 1696) : (iL[2] + 1696) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) (iL[2] + 1704) < 0 ? (iL[2] + 1704) : (iL[2] + 1704) + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 30020; + break _hb; + } + } + int ciTableIdx_26 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_26 = instance.table(0).requiredRef(ciTableIdx_26); + com.dylibso.chicory.runtime.Instance ciRefInstance_26 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_26), instance); + if (!ciRefInstance_26.type(ciRefInstance_26.functionType(ciFuncId_26)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_26 = new long[1]; + callArgs_26[0] = ((long) iL[3]); + ciRefInstance_26.getMachine().call(ciFuncId_26, callArgs_26); + { + _hs[0] = 30020; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_41__h5(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 148), memory.readInt((int) (iL[24] + 152) < 0 ? (iL[24] + 152) : (iL[24] + 152) + 0)) != 0) { + break _hb; + } + long[] callArgs_133 = new long[2]; + callArgs_133[1] = ((long) 9); + callArgs_133[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_133); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + long[] callArgs_134 = new long[3]; + callArgs_134[2] = ((long) 7706); + callArgs_134[1] = ((long) ((memory.readInt((int) (iL[24] + 152) < 0 ? (iL[24] + 152) : (iL[24] + 152) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 148)) >> 2)); + callArgs_134[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_134); + label_148: { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 148); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[37], memory.readInt((int) (iL[24] + 152) < 0 ? (iL[24] + 152) : (iL[24] + 152) + 0)) != 0) { + break label_148; + } + iL[25] = 0; + label_149: while (true) { + iL[37] = memory.readInt((int) (iL[37] + (iL[25] << 2)) < 0 ? (iL[37] + (iL[25] << 2)) : (iL[37] + (iL[25] << 2)) + 0); + label_150: { + iL[38] = memory.readInt((int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) < 0 ? (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) : (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_150; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 228, (int) iL[25]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 224, (int) 11716); + long[] callArgs_135 = new long[3]; + callArgs_135[2] = ((long) (iL[23] + 224)); + callArgs_135[1] = ((long) 32371); + callArgs_135[0] = ((long) iL[38]); + instance.getMachine().call(223, callArgs_135); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + long[] callArgs_136 = new long[2]; + callArgs_136[1] = ((long) iL[24]); + callArgs_136[0] = ((long) iL[37]); + long[] callResult_136 = instance.getMachine().call(163, callArgs_136); + iL[38] = ((int) callResult_136[0]); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (iL[38])); + long[] callArgs_137 = new long[5]; + callArgs_137[4] = ((long) 0); + callArgs_137[3] = ((long) 8272); + callArgs_137[2] = ((long) 1); + callArgs_137[1] = ((long) (iL[23] + 560)); + callArgs_137[0] = ((long) iL[24]); + instance.getMachine().call(224, callArgs_137); + label_151: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[38] & 2)) != 0) { + break label_151; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(2, memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0)) != 0) { + break label_151; + } + long[] callArgs_138 = new long[2]; + callArgs_138[1] = ((long) (iL[37] + 16)); + callArgs_138[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_138 = instance.getMachine().call(123, callArgs_138); + long[] callArgs_139 = new long[3]; + callArgs_139[2] = ((long) 2118); + callArgs_139[1] = ((long) ((int) callResult_138[0])); + callArgs_139[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_139); + } + label_152: { + if ((iL[38] & 1) != 0) { + break label_152; + } + label_153: { + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 60); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_153; + } + label_154: while (true) { + long[] callArgs_140 = new long[3]; + callArgs_140[2] = ((long) iL[24]); + callArgs_140[1] = ((long) 0); + callArgs_140[0] = ((long) iL[0]); + instance.getMachine().call(51, callArgs_140); + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + if (iL[24] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_154; + } + break; + } + } + long[] callArgs_141 = new long[2]; + callArgs_141[1] = ((long) 11); + callArgs_141[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_141); + } + iL[24] = (iL[38] & 4); + label_155: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[38] & 3)) != 0) { + break label_155; + } + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + label_156: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_156; + } + lL[0] = memory.readLong((int) iL[37] < 0 ? iL[37] : iL[37] + 52); + iL[36] = (int) lL[0]; + long[] callArgs_142 = new long[3]; + callArgs_142[2] = ((long) 15741); + callArgs_142[1] = ((long) iL[36]); + callArgs_142[0] = ((long) iL[38]); + instance.getMachine().call(173, callArgs_142); + iL[24] = 1; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, iL[36]) != 0) { + break label_155; + } + long[] callArgs_143 = new long[3]; + callArgs_143[2] = ((long) 15741); + callArgs_143[1] = ((long) (int) (lL[0] >>> 32L)); + callArgs_143[0] = ((long) iL[38]); + instance.getMachine().call(173, callArgs_143); + break label_155; + } + iL[24] = 0; + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (0)); + long[] callArgs_144 = new long[5]; + callArgs_144[4] = ((long) 0); + callArgs_144[3] = ((long) 15761); + callArgs_144[2] = ((long) 1); + callArgs_144[1] = ((long) (iL[23] + 560)); + callArgs_144[0] = ((long) iL[38]); + instance.getMachine().call(224, callArgs_144); + } + iL[38] = (iL[37] + 76); + long[] callArgs_145 = new long[3]; + callArgs_145[2] = ((long) 8117); + callArgs_145[1] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 0) - memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 72)), 12)); + callArgs_145[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_145); + iL[38] = memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 0); + iL[37] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 72); + label_157: { + label_158: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_158; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[37]) != 0) { + break label_157; + } + label_159: while (true) { + label_160: { + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_160; + } + label_161: while (true) { + long[] callArgs_146 = new long[3]; + callArgs_146[2] = ((long) iL[24]); + callArgs_146[1] = ((long) 0); + callArgs_146[0] = ((long) iL[0]); + instance.getMachine().call(51, callArgs_146); + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + if (iL[24] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_161; + } + break; + } + } + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 384, (int) 11); + long[] callArgs_147 = new long[2]; + callArgs_147[1] = ((long) (iL[23] + 384)); + callArgs_147[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(192, callArgs_147); + label_162: { + label_163: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 608) & 0xFF)) != 0) { + break label_163; + } + long[] callArgs_148 = new long[2]; + callArgs_148[1] = ((long) (iL[23] + 384)); + callArgs_148[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(192, callArgs_148); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (((int) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 608) & 0xFF))); + long[] callArgs_149 = new long[5]; + callArgs_149[4] = ((long) 0); + callArgs_149[3] = ((long) 1373); + callArgs_149[2] = ((long) 1); + callArgs_149[1] = ((long) (iL[23] + 560)); + callArgs_149[0] = ((long) iL[24]); + instance.getMachine().call(224, callArgs_149); + long[] callArgs_150 = new long[2]; + callArgs_150[1] = ((long) (iL[23] + 384)); + callArgs_150[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(192, callArgs_150); + iL[36] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 612); + long[] callArgs_151 = new long[2]; + callArgs_151[1] = ((long) (iL[23] + 384)); + callArgs_151[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(192, callArgs_151); + long[] callArgs_152 = new long[3]; + callArgs_152[2] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560)); + callArgs_152[1] = ((long) iL[36]); + callArgs_152[0] = ((long) iL[24]); + instance.getMachine().call(169, callArgs_152); + break label_162; + } + long[] callArgs_153 = new long[2]; + callArgs_153[1] = ((long) (iL[23] + 384)); + callArgs_153[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(192, callArgs_153); + iL[36] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 612); + long[] callArgs_154 = new long[2]; + callArgs_154[1] = ((long) (iL[23] + 384)); + callArgs_154[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(192, callArgs_154); + iL[30] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (iL[36])); + long[] callArgs_155 = new long[5]; + callArgs_155[4] = ((long) 0); + callArgs_155[3] = ((long) iL[30]); + callArgs_155[2] = ((long) 1); + callArgs_155[1] = ((long) (iL[23] + 560)); + callArgs_155[0] = ((long) iL[24]); + instance.getMachine().call(224, callArgs_155); + } + iL[37] = (iL[37] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[38], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_159; + } + break label_157; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[37]) != 0) { + break label_157; + } + label_164: while (true) { + long[] callArgs_156 = new long[2]; + callArgs_156[1] = ((long) (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0) + 36)); + callArgs_156[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_156 = instance.getMachine().call(121, callArgs_156); + long[] callArgs_157 = new long[3]; + callArgs_157[2] = ((long) 1513); + callArgs_157[1] = ((long) ((int) callResult_156[0])); + callArgs_157[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_157); + iL[37] = (iL[37] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[38], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_164; + } + break; + } + } + iL[25] = (iL[25] + 1); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 148); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[25], ((memory.readInt((int) (iL[24] + 152) < 0 ? (iL[24] + 152) : (iL[24] + 152) + 0) - iL[37]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_149; + } + break; + } + } + long[] callArgs_158 = new long[4]; + callArgs_158[3] = ((long) 15012); + callArgs_158[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_158[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_158[0] = ((long) iL[0]); + long[] callResult_158 = instance.getMachine().call(48, callArgs_158); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + } while (false); + return _hs[0]; + } + + private static int func_801__h10(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_441: { + label_442: { + switch((iL[17] + -7)) { + case 0: + { + break label_441; + } + case 1: + { + { + _hs[0] = 10010; + break _hb; + } + } + case 2: + { + { + _hs[0] = 10010; + break _hb; + } + } + case 3: + { + { + _hs[0] = 10010; + break _hb; + } + } + case 4: + { + { + _hs[0] = 10010; + break _hb; + } + } + case 5: + { + { + _hs[0] = 10010; + break _hb; + } + } + case 6: + { + { + _hs[0] = 10010; + break _hb; + } + } + case 7: + { + { + _hs[0] = 10010; + break _hb; + } + } + case 8: + { + break label_442; + } + default: + { + { + _hs[0] = 10010; + break _hb; + } + } + } + } + long[] callArgs_477 = new long[3]; + callArgs_477[2] = ((long) 15); + callArgs_477[1] = ((long) 8421); + callArgs_477[0] = ((long) iL[18]); + long[] callResult_477 = instance.getMachine().call(1889, callArgs_477); + if (((int) callResult_477[0]) != 0) { + { + _hs[0] = 10011; + break _hb; + } + } + label_443: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_478 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 776)); + int ciFuncId_478 = instance.table(0).requiredRef(ciTableIdx_478); + com.dylibso.chicory.runtime.Instance ciRefInstance_478 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_478), instance); + if (!ciRefInstance_478.type(ciRefInstance_478.functionType(ciFuncId_478)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_478 = new long[2]; + callArgs_478[1] = ((long) iL[0]); + callArgs_478[0] = ((long) iL[3]); + long[] callResult_478 = ciRefInstance_478.getMachine().call(ciFuncId_478, callArgs_478); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_478[0])) != 0) { + break label_443; + } + long[] callArgs_479 = new long[3]; + callArgs_479[2] = ((long) 0); + callArgs_479[1] = ((long) 23539); + callArgs_479[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_479); + { + _hs[0] = 10002; + break _hb; + } + } + label_444: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_480 = new long[3]; + callArgs_480[2] = ((long) (iL[4] + 3248)); + callArgs_480[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_480[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_480 = instance.getMachine().call(177, callArgs_480); + iL[3] = ((int) callResult_480[0]); + if (iL[3] != 0) { + break label_444; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 848, (int) 6412); + long[] callArgs_481 = new long[3]; + callArgs_481[2] = ((long) (iL[4] + 848)); + callArgs_481[1] = ((long) 11260); + callArgs_481[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_481); + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3])); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_482 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 780)); + int ciFuncId_482 = instance.table(0).requiredRef(ciTableIdx_482); + com.dylibso.chicory.runtime.Instance ciRefInstance_482 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_482), instance); + if (!ciRefInstance_482.type(ciRefInstance_482.functionType(ciFuncId_482)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_482 = new long[2]; + callArgs_482[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3248)); + callArgs_482[0] = ((long) iL[3]); + long[] callResult_482 = ciRefInstance_482.getMachine().call(ciFuncId_482, callArgs_482); + if (((int) callResult_482[0]) != 0) { + break _hb; + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3248); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3248, (int) (iL[3] + -1)); + label_445: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_445; + } + label_446: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + label_447: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[0] = (iL[3] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[0], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)) != 0) { + break label_447; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 868, (int) 1373); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 864, (int) 7656); + long[] callArgs_483 = new long[3]; + callArgs_483[2] = ((long) (iL[4] + 864)); + callArgs_483[1] = ((long) 10873); + callArgs_483[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_483); + { + _hs[0] = 10002; + break _hb; + } + } + iL[3] = ((int) memory.read((int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[3]) < 0 ? (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[3]) : (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[3]) + 0) & 0xFF); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + long[] callArgs_484 = new long[3]; + callArgs_484[2] = ((long) 16918); + callArgs_484[1] = ((long) (iL[4] + 3168)); + callArgs_484[0] = ((long) (iL[4] + 2936)); + long[] callResult_484 = instance.getMachine().call(803, callArgs_484); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_484[0])) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) lL[0]); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[13] = memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 784); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 872, (long) lL[0]); + label_448: { + int ciTableIdx_485 = (int) (iL[13]); + int ciFuncId_485 = instance.table(0).requiredRef(ciTableIdx_485); + com.dylibso.chicory.runtime.Instance ciRefInstance_485 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_485), instance); + if (!ciRefInstance_485.type(ciRefInstance_485.functionType(ciFuncId_485)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_485 = new long[3]; + callArgs_485[2] = ((long) (iL[4] + 872)); + callArgs_485[1] = ((long) (iL[3] & 255)); + callArgs_485[0] = ((long) iL[0]); + long[] callResult_485 = ciRefInstance_485.getMachine().call(ciFuncId_485, callArgs_485); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_485[0])) != 0) { + break label_448; + } + long[] callArgs_486 = new long[3]; + callArgs_486[2] = ((long) 0); + callArgs_486[1] = ((long) 25102); + callArgs_486[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_486); + { + _hs[0] = 10002; + break _hb; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3248); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3248, (int) (iL[3] + -1)); + if (iL[3] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_446; + } + break; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_487 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 788)); + int ciFuncId_487 = instance.table(0).requiredRef(ciTableIdx_487); + com.dylibso.chicory.runtime.Instance ciRefInstance_487 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_487), instance); + if (!ciRefInstance_487.type(ciRefInstance_487.functionType(ciFuncId_487)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_487 = new long[1]; + callArgs_487[0] = ((long) iL[3]); + long[] callResult_487 = ciRefInstance_487.getMachine().call(ciFuncId_487, callArgs_487); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_487[0])) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + long[] callArgs_488 = new long[3]; + callArgs_488[2] = ((long) 0); + callArgs_488[1] = ((long) 23582); + callArgs_488[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_488); + { + _hs[0] = 10002; + break _hb; + } + } + long[] callArgs_489 = new long[3]; + callArgs_489[2] = ((long) 7); + callArgs_489[1] = ((long) 14424); + callArgs_489[0] = ((long) iL[18]); + long[] callResult_489 = instance.getMachine().call(1889, callArgs_489); + if (((int) callResult_489[0]) != 0) { + { + _hs[0] = 10012; + break _hb; + } + } + label_449: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_490 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 804)); + int ciFuncId_490 = instance.table(0).requiredRef(ciTableIdx_490); + com.dylibso.chicory.runtime.Instance ciRefInstance_490 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_490), instance); + if (!ciRefInstance_490.type(ciRefInstance_490.functionType(ciFuncId_490)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_490 = new long[2]; + callArgs_490[1] = ((long) iL[0]); + callArgs_490[0] = ((long) iL[3]); + long[] callResult_490 = ciRefInstance_490.getMachine().call(ciFuncId_490, callArgs_490); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_490[0])) != 0) { + break label_449; + } + long[] callArgs_491 = new long[3]; + callArgs_491[2] = ((long) 0); + callArgs_491[1] = ((long) 24179); + callArgs_491[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_491); + { + _hs[0] = 10002; + break _hb; + } + } + label_450: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_492 = new long[3]; + callArgs_492[2] = ((long) (iL[4] + 3152)); + callArgs_492[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_492[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_492 = instance.getMachine().call(177, callArgs_492); + iL[3] = ((int) callResult_492[0]); + if (iL[3] != 0) { + break label_450; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 880, (int) 12777); + long[] callArgs_493 = new long[3]; + callArgs_493[2] = ((long) (iL[4] + 880)); + callArgs_493[1] = ((long) 11260); + callArgs_493[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_493); + { + _hs[0] = 10002; + break _hb; + } + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_451: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(2, iL[0]) != 0) { + break label_451; + } + label_452: { + label_453: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[3], iL[0]) != 0) { + break label_453; + } + label_454: while (true) { + label_455: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_494 = new long[3]; + callArgs_494[2] = ((long) (iL[4] + 3144)); + callArgs_494[1] = ((long) (iL[13] + iL[0])); + callArgs_494[0] = ((long) (iL[13] + iL[3])); + long[] callResult_494 = instance.getMachine().call(177, callArgs_494); + iL[0] = ((int) callResult_494[0]); + if (iL[0] != 0) { + break label_455; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 896, (int) 16363); + long[] callArgs_495 = new long[3]; + callArgs_495[2] = ((long) (iL[4] + 896)); + callArgs_495[1] = ((long) 11260); + callArgs_495[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_495); + { + _hs[0] = 10002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_456: { + long[] callArgs_496 = new long[3]; + callArgs_496[2] = ((long) (iL[4] + 3168)); + callArgs_496[1] = ((long) (iL[3] + iL[13])); + callArgs_496[0] = ((long) (iL[3] + iL[0])); + long[] callResult_496 = instance.getMachine().call(177, callArgs_496); + iL[3] = ((int) callResult_496[0]); + if (iL[3] != 0) { + break label_456; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 912, (int) 14996); + long[] callArgs_497 = new long[3]; + callArgs_497[2] = ((long) (iL[4] + 912)); + callArgs_497[1] = ((long) 11260); + callArgs_497[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_497); + { + _hs[0] = 10002; + break _hb; + } + } + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_457: { + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168) + iL[13]); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_457; + } + long[] callArgs_498 = new long[3]; + callArgs_498[2] = ((long) 0); + callArgs_498[1] = ((long) 17707); + callArgs_498[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_498); + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[3]); + label_458: { + int _d6 = func_801__h6(iL, lL, memory, instance); + if (_d6 == 1) + break label_452; + if (_d6 >= 10000) { + _hs[0] = ((_d6 - 10000)) + 10000; + break _hb; + } + } + label_506: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948)) != 0) { + break label_506; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 928, (int) iL[3]); + long[] callArgs_569 = new long[3]; + callArgs_569[2] = ((long) (iL[4] + 928)); + callArgs_569[1] = ((long) 29336); + callArgs_569[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_569); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[3], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_454; + } + break; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_570 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 864)); + int ciFuncId_570 = instance.table(0).requiredRef(ciTableIdx_570); + com.dylibso.chicory.runtime.Instance ciRefInstance_570 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_570), instance); + if (!ciRefInstance_570.type(ciRefInstance_570.functionType(ciFuncId_570)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_570 = new long[1]; + callArgs_570[0] = ((long) iL[3]); + long[] callResult_570 = ciRefInstance_570.getMachine().call(ciFuncId_570, callArgs_570); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_570[0])) != 0) { + { + _hs[0] = 10004; + break _hb; + } + } + long[] callArgs_571 = new long[3]; + callArgs_571[2] = ((long) 0); + callArgs_571[1] = ((long) 24215); + callArgs_571[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_571); + { + _hs[0] = 10002; + break _hb; + } + } + long[] callArgs_572 = new long[3]; + callArgs_572[2] = ((long) 0); + callArgs_572[1] = ((long) 19636); + callArgs_572[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_572); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 10002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1296, (int) iL[0]); + long[] callArgs_573 = new long[3]; + callArgs_573[2] = ((long) (iL[4] + 1296)); + callArgs_573[1] = ((long) 5584); + callArgs_573[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_573); + { + _hs[0] = 10002; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h11(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_50: { + label_51: { + int _d7 = func_801__h7(iL, lL, memory, instance); + if (_d7 == 1) { + _hs[0] = 1; + break _hb; + } + if (_d7 == 2) + break _hb; + if (_d7 == 3) + break label_50; + if (_d7 >= 10000) { + _hs[0] = ((_d7 - 10000)) + 10000; + break _hb; + } + } + label_261: { + label_262: { + label_263: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_283 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 188)); + int ciFuncId_283 = instance.table(0).requiredRef(ciTableIdx_283); + com.dylibso.chicory.runtime.Instance ciRefInstance_283 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_283), instance); + if (!ciRefInstance_283.type(ciRefInstance_283.functionType(ciFuncId_283)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_283 = new long[2]; + callArgs_283[1] = ((long) iL[0]); + callArgs_283[0] = ((long) iL[3]); + long[] callResult_283 = ciRefInstance_283.getMachine().call(ciFuncId_283, callArgs_283); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_283[0])) != 0) { + break label_263; + } + long[] callArgs_284 = new long[3]; + callArgs_284[2] = ((long) 0); + callArgs_284[1] = ((long) 23399); + callArgs_284[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_284); + break label_262; + } + label_264: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_285 = new long[3]; + callArgs_285[2] = ((long) (iL[4] + 3168)); + callArgs_285[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_285[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_285 = instance.getMachine().call(177, callArgs_285); + iL[3] = ((int) callResult_285[0]); + if (iL[3] != 0) { + break label_264; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2320, (int) 1492); + long[] callArgs_286 = new long[3]; + callArgs_286[2] = ((long) (iL[4] + 2320)); + callArgs_286[1] = ((long) 11260); + callArgs_286[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_286); + break label_262; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3])); + label_265: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_287 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 192)); + int ciFuncId_287 = instance.table(0).requiredRef(ciTableIdx_287); + com.dylibso.chicory.runtime.Instance ciRefInstance_287 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_287), instance); + if (!ciRefInstance_287.type(ciRefInstance_287.functionType(ciFuncId_287)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_287 = new long[2]; + callArgs_287[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168)); + callArgs_287[0] = ((long) iL[3]); + long[] callResult_287 = ciRefInstance_287.getMachine().call(ciFuncId_287, callArgs_287); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_287[0])) != 0) { + break label_265; + } + long[] callArgs_288 = new long[3]; + callArgs_288[2] = ((long) 0); + callArgs_288[1] = ((long) 22954); + callArgs_288[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_288); + break label_262; + } + label_266: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_289 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 196)); + int ciFuncId_289 = instance.table(0).requiredRef(ciTableIdx_289); + com.dylibso.chicory.runtime.Instance ciRefInstance_289 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_289), instance); + if (!ciRefInstance_289.type(ciRefInstance_289.functionType(ciFuncId_289)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_289 = new long[1]; + callArgs_289[0] = ((long) iL[3]); + long[] callResult_289 = ciRefInstance_289.getMachine().call(ciFuncId_289, callArgs_289); + if (((int) callResult_289[0]) != 0) { + break label_266; + } + iL[3] = 0; + break label_261; + } + long[] callArgs_290 = new long[3]; + callArgs_290[2] = ((long) 0); + callArgs_290[1] = ((long) 23433); + callArgs_290[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_290); + } + iL[3] = 1; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 20009; + break _hb; + } + } + label_267: { + label_268: { + label_269: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_291 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 172)); + int ciFuncId_291 = instance.table(0).requiredRef(ciTableIdx_291); + com.dylibso.chicory.runtime.Instance ciRefInstance_291 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_291), instance); + if (!ciRefInstance_291.type(ciRefInstance_291.functionType(ciFuncId_291)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_291 = new long[2]; + callArgs_291[1] = ((long) iL[0]); + callArgs_291[0] = ((long) iL[3]); + long[] callResult_291 = ciRefInstance_291.getMachine().call(ciFuncId_291, callArgs_291); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_291[0])) != 0) { + break label_269; + } + long[] callArgs_292 = new long[3]; + callArgs_292[2] = ((long) 0); + callArgs_292[1] = ((long) 23263); + callArgs_292[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_292); + break label_268; + } + label_270: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_293 = new long[3]; + callArgs_293[2] = ((long) (iL[4] + 3168)); + callArgs_293[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_293[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_293 = instance.getMachine().call(177, callArgs_293); + iL[3] = ((int) callResult_293[0]); + if (iL[3] != 0) { + break label_270; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2240, (int) 6212); + long[] callArgs_294 = new long[3]; + callArgs_294[2] = ((long) (iL[4] + 2240)); + callArgs_294[1] = ((long) 11260); + callArgs_294[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_294); + break label_268; + } + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_271: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_271; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2264, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2260, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2256, (int) 6212); + long[] callArgs_295 = new long[3]; + callArgs_295[2] = ((long) (iL[4] + 2256)); + callArgs_295[1] = ((long) 12552); + callArgs_295[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_295); + break label_268; + } + label_272: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_296 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 176)); + int ciFuncId_296 = instance.table(0).requiredRef(ciTableIdx_296); + com.dylibso.chicory.runtime.Instance ciRefInstance_296 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_296), instance); + if (!ciRefInstance_296.type(ciRefInstance_296.functionType(ciFuncId_296)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_296 = new long[2]; + callArgs_296[1] = ((long) iL[3]); + callArgs_296[0] = ((long) iL[0]); + long[] callResult_296 = ciRefInstance_296.getMachine().call(ciFuncId_296, callArgs_296); + if (((int) callResult_296[0]) != 0) { + break label_272; + } + label_273: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_273; + } + iL[15] = 0; + label_274: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_297 = new long[3]; + callArgs_297[2] = ((long) 16868); + callArgs_297[1] = ((long) (iL[4] + 3168)); + callArgs_297[0] = ((long) (iL[4] + 2936)); + long[] callResult_297 = instance.getMachine().call(803, callArgs_297); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_297[0])) != 0) { + break label_268; + } + label_275: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[13] = (iL[0] + 1); + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[13], iL[16]) != 0) { + break label_275; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2276, (int) 17653); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2272, (int) 7656); + long[] callArgs_298 = new long[3]; + callArgs_298[2] = ((long) (iL[4] + 2272)); + callArgs_298[1] = ((long) 10873); + callArgs_298[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_298); + break label_268; + } + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[0] = ((int) memory.read((int) (iL[14] + iL[0]) < 0 ? (iL[14] + iL[0]) : (iL[14] + iL[0]) + 0) & 0xFF); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_276: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[0], 5) != 0) { + break label_276; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2304, (int) iL[0]); + long[] callArgs_299 = new long[3]; + callArgs_299[2] = ((long) (iL[4] + 2304)); + callArgs_299[1] = ((long) 26383); + callArgs_299[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_299); + break label_268; + } + label_277: { + long[] callArgs_300 = new long[3]; + callArgs_300[2] = ((long) (iL[4] + 3248)); + callArgs_300[1] = ((long) (iL[14] + iL[16])); + callArgs_300[0] = ((long) (iL[14] + iL[13])); + long[] callResult_300 = instance.getMachine().call(177, callArgs_300); + iL[13] = ((int) callResult_300[0]); + if (iL[13] != 0) { + break label_277; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2288, (int) 1599); + long[] callArgs_301 = new long[3]; + callArgs_301[2] = ((long) (iL[4] + 2288)); + callArgs_301[1] = ((long) 11260); + callArgs_301[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_301); + break label_268; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3248); + label_278: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(4, iL[0]) != 0) { + break label_278; + } + if (((int) memory.read((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) + 0) & 0xFF) != 0) { + break label_278; + } + long[] callArgs_302 = new long[3]; + callArgs_302[2] = ((long) 0); + callArgs_302[1] = ((long) 18072); + callArgs_302[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_302); + break label_268; + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) lL[0]); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[16] = memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 180); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 2296, (long) lL[0]); + label_279: { + int ciTableIdx_303 = (int) (iL[16]); + int ciFuncId_303 = instance.table(0).requiredRef(ciTableIdx_303); + com.dylibso.chicory.runtime.Instance ciRefInstance_303 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_303), instance); + if (!ciRefInstance_303.type(ciRefInstance_303.functionType(ciFuncId_303)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_303 = new long[5]; + callArgs_303[4] = ((long) (iL[4] + 2296)); + callArgs_303[3] = ((long) iL[13]); + callArgs_303[2] = ((long) iL[0]); + callArgs_303[1] = ((long) iL[15]); + callArgs_303[0] = ((long) iL[14]); + long[] callResult_303 = ciRefInstance_303.getMachine().call(ciFuncId_303, callArgs_303); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_303[0])) != 0) { + break label_279; + } + long[] callArgs_304 = new long[3]; + callArgs_304[2] = ((long) 0); + callArgs_304[1] = ((long) 19111); + callArgs_304[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_304); + break label_268; + } + iL[15] = (iL[15] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[15], iL[3]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_274; + } + break; + } + } + label_280: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_305 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 184)); + int ciFuncId_305 = instance.table(0).requiredRef(ciTableIdx_305); + com.dylibso.chicory.runtime.Instance ciRefInstance_305 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_305), instance); + if (!ciRefInstance_305.type(ciRefInstance_305.functionType(ciFuncId_305)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_305 = new long[1]; + callArgs_305[0] = ((long) iL[3]); + long[] callResult_305 = ciRefInstance_305.getMachine().call(ciFuncId_305, callArgs_305); + if (((int) callResult_305[0]) != 0) { + break label_280; + } + iL[3] = 0; + break label_267; + } + long[] callArgs_306 = new long[3]; + callArgs_306[2] = ((long) 0); + callArgs_306[1] = ((long) 23298); + callArgs_306[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_306); + break label_268; + } + long[] callArgs_307 = new long[3]; + callArgs_307[2] = ((long) 0); + callArgs_307[1] = ((long) 19289); + callArgs_307[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_307); + } + iL[3] = 1; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 20009; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h12(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_328: { + label_329: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_361 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 60)); + int ciFuncId_361 = instance.table(0).requiredRef(ciTableIdx_361); + com.dylibso.chicory.runtime.Instance ciRefInstance_361 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_361), instance); + if (!ciRefInstance_361.type(ciRefInstance_361.functionType(ciFuncId_361)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_361 = new long[2]; + callArgs_361[1] = ((long) iL[0]); + callArgs_361[0] = ((long) iL[3]); + long[] callResult_361 = ciRefInstance_361.getMachine().call(ciFuncId_361, callArgs_361); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_361[0])) != 0) { + break label_329; + } + long[] callArgs_362 = new long[3]; + callArgs_362[2] = ((long) 0); + callArgs_362[1] = ((long) 23331); + callArgs_362[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_362); + break label_328; + } + label_330: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_363 = new long[3]; + callArgs_363[2] = ((long) (iL[4] + 3168)); + callArgs_363[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_363[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_363 = instance.getMachine().call(177, callArgs_363); + iL[3] = ((int) callResult_363[0]); + if (iL[3] != 0) { + break label_330; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1840, (int) 6225); + long[] callArgs_364 = new long[3]; + callArgs_364[2] = ((long) (iL[4] + 1840)); + callArgs_364[1] = ((long) 11260); + callArgs_364[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_364); + break label_328; + } + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_331: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_331; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1864, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1860, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1856, (int) 6225); + long[] callArgs_365 = new long[3]; + callArgs_365[2] = ((long) (iL[4] + 1856)); + callArgs_365[1] = ((long) 12552); + callArgs_365[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_365); + break label_328; + } + label_332: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_366 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 64)); + int ciFuncId_366 = instance.table(0).requiredRef(ciTableIdx_366); + com.dylibso.chicory.runtime.Instance ciRefInstance_366 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_366), instance); + if (!ciRefInstance_366.type(ciRefInstance_366.functionType(ciFuncId_366)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_366 = new long[2]; + callArgs_366[1] = ((long) iL[3]); + callArgs_366[0] = ((long) iL[0]); + long[] callResult_366 = ciRefInstance_366.getMachine().call(ciFuncId_366, callArgs_366); + if (((int) callResult_366[0]) != 0) { + break label_332; + } + label_333: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_333; + } + iL[0] = 0; + label_334: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) 0L); + long[] callArgs_367 = new long[3]; + callArgs_367[2] = ((long) 16931); + callArgs_367[1] = ((long) (iL[4] + 3256)); + callArgs_367[0] = ((long) (iL[4] + 2936)); + long[] callResult_367 = instance.getMachine().call(803, callArgs_367); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_367[0])) != 0) { + break label_328; + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3248, (long) 0L); + long[] callArgs_368 = new long[3]; + callArgs_368[2] = ((long) 16961); + callArgs_368[1] = ((long) (iL[4] + 3248)); + callArgs_368[0] = ((long) (iL[4] + 2936)); + long[] callResult_368 = instance.getMachine().call(803, callArgs_368); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_368[0])) != 0) { + break label_328; + } + label_335: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[14] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[14], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)) != 0) { + break label_335; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1876, (int) 17665); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1872, (int) 7656); + long[] callArgs_369 = new long[3]; + callArgs_369[2] = ((long) (iL[4] + 1872)); + callArgs_369[1] = ((long) 10873); + callArgs_369[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_369); + break label_328; + } + iL[13] = ((int) memory.read((int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[13]) < 0 ? (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[13]) : (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[13]) + 0) & 0xFF); + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3240, (long) lL[0]); + lL[1] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3248); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3232, (long) lL[1]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[14]); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[15] = memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 68); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 2056, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 2048, (long) lL[1]); + label_336: { + int ciTableIdx_370 = (int) (iL[15]); + int ciFuncId_370 = instance.table(0).requiredRef(ciTableIdx_370); + com.dylibso.chicory.runtime.Instance ciRefInstance_370 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_370), instance); + if (!ciRefInstance_370.type(ciRefInstance_370.functionType(ciFuncId_370)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_370 = new long[5]; + callArgs_370[4] = ((long) (iL[4] + 2048)); + callArgs_370[3] = ((long) (iL[4] + 2056)); + callArgs_370[2] = ((long) iL[13]); + callArgs_370[1] = ((long) iL[0]); + callArgs_370[0] = ((long) iL[14]); + long[] callResult_370 = ciRefInstance_370.getMachine().call(ciFuncId_370, callArgs_370); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_370[0])) != 0) { + break label_336; + } + long[] callArgs_371 = new long[3]; + callArgs_371[2] = ((long) 0); + callArgs_371[1] = ((long) 19167); + callArgs_371[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_371); + break label_328; + } + label_337: { + label_338: { + label_339: { + label_340: { + label_341: { + label_342: { + label_343: { + label_344: { + switch(iL[13]) { + case 0: + { + break label_344; + } + case 1: + { + break label_343; + } + case 2: + { + break label_342; + } + case 3: + { + break label_341; + } + case 4: + { + break label_340; + } + default: + { + break label_339; + } + } + } + label_345: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_372 = new long[3]; + callArgs_372[2] = ((long) (iL[4] + 3168)); + callArgs_372[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_372[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_372 = instance.getMachine().call(177, callArgs_372); + iL[13] = ((int) callResult_372[0]); + if (iL[13] != 0) { + break label_345; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1904, (int) 1792); + long[] callArgs_373 = new long[3]; + callArgs_373[2] = ((long) (iL[4] + 1904)); + callArgs_373[1] = ((long) 11260); + callArgs_373[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_373); + break label_328; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3224, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3216, (long) lL[1]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[15] = memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 72); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1928, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1920, (long) lL[1]); + int ciTableIdx_374 = (int) (iL[15]); + int ciFuncId_374 = instance.table(0).requiredRef(ciTableIdx_374); + com.dylibso.chicory.runtime.Instance ciRefInstance_374 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_374), instance); + if (!ciRefInstance_374.type(ciRefInstance_374.functionType(ciFuncId_374)).typesMatch(instance.type(7))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_374 = new long[6]; + callArgs_374[5] = ((long) iL[13]); + callArgs_374[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3048)); + callArgs_374[3] = ((long) (iL[4] + 1920)); + callArgs_374[2] = ((long) (iL[4] + 1928)); + callArgs_374[1] = ((long) iL[0]); + callArgs_374[0] = ((long) iL[14]); + long[] callResult_374 = ciRefInstance_374.getMachine().call(ciFuncId_374, callArgs_374); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_374[0])) != 0) { + break label_338; + } + long[] callArgs_375 = new long[3]; + callArgs_375[2] = ((long) 0); + callArgs_375[1] = ((long) 25610); + callArgs_375[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_375); + break label_328; + } + memory.writeI32((int) ((iL[4] + 3168) + 15) < 0 ? ((iL[4] + 3168) + 15) : ((iL[4] + 3168) + 15) + 0, (int) 0); + memory.writeLong((int) ((iL[4] + 3168) + 8) < 0 ? ((iL[4] + 3168) + 8) : ((iL[4] + 3168) + 8) + 0, (long) 0L); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_376 = new long[3]; + callArgs_376[2] = ((long) (iL[4] + 3168)); + callArgs_376[1] = ((long) (iL[4] + 3208)); + callArgs_376[0] = ((long) (iL[4] + 2936)); + long[] callResult_376 = instance.getMachine().call(808, callArgs_376); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_376[0])) != 0) { + break label_328; + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3200, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3192, (long) lL[1]); + lL[2] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3208); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3160, (long) lL[2]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[14] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 76); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1952, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1936, (long) lL[2]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1944, (long) lL[1]); + label_346: { + int ciTableIdx_377 = (int) (iL[14]); + int ciFuncId_377 = instance.table(0).requiredRef(ciTableIdx_377); + com.dylibso.chicory.runtime.Instance ciRefInstance_377 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_377), instance); + if (!ciRefInstance_377.type(ciRefInstance_377.functionType(ciFuncId_377)).typesMatch(instance.type(9))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_377 = new long[7]; + callArgs_377[6] = ((long) (iL[4] + 3168)); + callArgs_377[5] = ((long) (iL[4] + 1936)); + callArgs_377[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3052)); + callArgs_377[3] = ((long) (iL[4] + 1944)); + callArgs_377[2] = ((long) (iL[4] + 1952)); + callArgs_377[1] = ((long) iL[0]); + callArgs_377[0] = ((long) iL[13]); + long[] callResult_377 = ciRefInstance_377.getMachine().call(ciFuncId_377, callArgs_377); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_377[0])) != 0) { + break label_346; + } + long[] callArgs_378 = new long[3]; + callArgs_378[2] = ((long) 0); + callArgs_378[1] = ((long) 25476); + callArgs_378[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_378); + break label_328; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3052, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3052) + 1)); + break label_337; + } + memory.writeI32((int) ((iL[4] + 3168) + 15) < 0 ? ((iL[4] + 3168) + 15) : ((iL[4] + 3168) + 15) + 0, (int) 0); + memory.writeLong((int) ((iL[4] + 3168) + 8) < 0 ? ((iL[4] + 3168) + 8) : ((iL[4] + 3168) + 8) + 0, (long) 0L); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_379 = new long[3]; + callArgs_379[2] = ((long) (iL[4] + 3208)); + callArgs_379[1] = ((long) (iL[4] + 3168)); + callArgs_379[0] = ((long) (iL[4] + 2936)); + long[] callResult_379 = instance.getMachine().call(807, callArgs_379); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_379[0])) != 0) { + break label_328; + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3152, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3144, (long) lL[1]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[14] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 80); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1968, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1960, (long) lL[1]); + label_347: { + int ciTableIdx_380 = (int) (iL[14]); + int ciFuncId_380 = instance.table(0).requiredRef(ciTableIdx_380); + com.dylibso.chicory.runtime.Instance ciRefInstance_380 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_380), instance); + if (!ciRefInstance_380.type(ciRefInstance_380.functionType(ciFuncId_380)).typesMatch(instance.type(9))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_380 = new long[7]; + callArgs_380[6] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3208)); + callArgs_380[5] = ((long) (iL[4] + 3168)); + callArgs_380[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3056)); + callArgs_380[3] = ((long) (iL[4] + 1960)); + callArgs_380[2] = ((long) (iL[4] + 1968)); + callArgs_380[1] = ((long) iL[0]); + callArgs_380[0] = ((long) iL[13]); + long[] callResult_380 = ciRefInstance_380.getMachine().call(ciFuncId_380, callArgs_380); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_380[0])) != 0) { + break label_347; + } + long[] callArgs_381 = new long[3]; + callArgs_381[2] = ((long) 0); + callArgs_381[1] = ((long) 18959); + callArgs_381[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_381); + break label_328; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3056, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3056) + 1)); + break label_337; + } + long[] callArgs_382 = new long[3]; + callArgs_382[2] = ((long) (iL[4] + 3208)); + callArgs_382[1] = ((long) (iL[4] + 3168)); + callArgs_382[0] = ((long) (iL[4] + 2936)); + long[] callResult_382 = instance.getMachine().call(806, callArgs_382); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_382[0])) != 0) { + break label_328; + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3136, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3128, (long) lL[1]); + lL[2] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3120, (long) lL[2]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[14] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 84); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1976, (long) lL[2]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1984, (long) lL[1]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1992, (long) lL[0]); + label_348: { + int ciTableIdx_383 = (int) (iL[14]); + int ciFuncId_383 = instance.table(0).requiredRef(ciTableIdx_383); + com.dylibso.chicory.runtime.Instance ciRefInstance_383 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_383), instance); + if (!ciRefInstance_383.type(ciRefInstance_383.functionType(ciFuncId_383)).typesMatch(instance.type(9))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_383 = new long[7]; + callArgs_383[6] = ((long) ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 3208) & 0xFF)); + callArgs_383[5] = ((long) (iL[4] + 1976)); + callArgs_383[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3060)); + callArgs_383[3] = ((long) (iL[4] + 1984)); + callArgs_383[2] = ((long) (iL[4] + 1992)); + callArgs_383[1] = ((long) iL[0]); + callArgs_383[0] = ((long) iL[13]); + long[] callResult_383 = ciRefInstance_383.getMachine().call(ciFuncId_383, callArgs_383); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_383[0])) != 0) { + break label_348; + } + long[] callArgs_384 = new long[3]; + callArgs_384[2] = ((long) 0); + callArgs_384[1] = ((long) 24956); + callArgs_384[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_384); + break label_328; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3060, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3060) + 1)); + break label_337; + } + label_349: { + if (((int) memory.read((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) + 0) & 0xFF) != 0) { + break label_349; + } + long[] callArgs_385 = new long[3]; + callArgs_385[2] = ((long) 0); + callArgs_385[1] = ((long) 18120); + callArgs_385[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_385); + break label_328; + } + label_350: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[13] = (iL[15] + 1); + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[13], iL[16]) != 0) { + break label_350; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2004, (int) 15538); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2000, (int) 7656); + long[] callArgs_386 = new long[3]; + callArgs_386[2] = ((long) (iL[4] + 2000)); + callArgs_386[1] = ((long) 10873); + callArgs_386[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_386); + break label_328; + } + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[15] = ((int) memory.read((int) (iL[14] + iL[15]) < 0 ? (iL[14] + iL[15]) : (iL[14] + iL[15]) + 0) & 0xFF); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_351: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[15]) != 0) { + break label_351; + } + long[] callArgs_387 = new long[3]; + callArgs_387[2] = ((long) 0); + callArgs_387[1] = ((long) 28739); + callArgs_387[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_387); + break label_328; + } + label_352: { + long[] callArgs_388 = new long[3]; + callArgs_388[2] = ((long) (iL[4] + 3168)); + callArgs_388[1] = ((long) (iL[14] + iL[16])); + callArgs_388[0] = ((long) (iL[14] + iL[13])); + long[] callResult_388 = instance.getMachine().call(177, callArgs_388); + iL[13] = ((int) callResult_388[0]); + if (iL[13] != 0) { + break label_352; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2016, (int) 1870); + long[] callArgs_389 = new long[3]; + callArgs_389[2] = ((long) (iL[4] + 2016)); + callArgs_389[1] = ((long) 11260); + callArgs_389[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_389); + break label_328; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3112, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3104, (long) lL[1]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[15] = memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 88); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 2040, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 2032, (long) lL[1]); + label_353: { + int ciTableIdx_390 = (int) (iL[15]); + int ciFuncId_390 = instance.table(0).requiredRef(ciTableIdx_390); + com.dylibso.chicory.runtime.Instance ciRefInstance_390 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_390), instance); + if (!ciRefInstance_390.type(ciRefInstance_390.functionType(ciFuncId_390)).typesMatch(instance.type(7))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_390 = new long[6]; + callArgs_390[5] = ((long) iL[13]); + callArgs_390[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3064)); + callArgs_390[3] = ((long) (iL[4] + 2032)); + callArgs_390[2] = ((long) (iL[4] + 2040)); + callArgs_390[1] = ((long) iL[0]); + callArgs_390[0] = ((long) iL[14]); + long[] callResult_390 = ciRefInstance_390.getMachine().call(ciFuncId_390, callArgs_390); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_390[0])) != 0) { + break label_353; + } + long[] callArgs_391 = new long[3]; + callArgs_391[2] = ((long) 0); + callArgs_391[1] = ((long) 25074); + callArgs_391[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_391); + break label_328; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3064, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3064) + 1)); + break label_337; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1888, (int) iL[13]); + long[] callArgs_392 = new long[3]; + callArgs_392[2] = ((long) (iL[4] + 1888)); + callArgs_392[1] = ((long) 26357); + callArgs_392[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_392); + break label_328; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3048, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3048) + 1)); + } + iL[0] = (iL[0] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[0], iL[3]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_334; + } + break; + } + } + label_354: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_393 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 92)); + int ciFuncId_393 = instance.table(0).requiredRef(ciTableIdx_393); + com.dylibso.chicory.runtime.Instance ciRefInstance_393 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_393), instance); + if (!ciRefInstance_393.type(ciRefInstance_393.functionType(ciFuncId_393)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_393 = new long[1]; + callArgs_393[0] = ((long) iL[3]); + long[] callResult_393 = ciRefInstance_393.getMachine().call(ciFuncId_393, callArgs_393); + if (((int) callResult_393[0]) != 0) { + break label_354; + } + iL[3] = 0; + break _hb; + } + long[] callArgs_394 = new long[3]; + callArgs_394[2] = ((long) 0); + callArgs_394[1] = ((long) 23366); + callArgs_394[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_394); + break label_328; + } + long[] callArgs_395 = new long[3]; + callArgs_395[2] = ((long) 0); + callArgs_395[1] = ((long) 19355); + callArgs_395[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_395); + } + iL[3] = 1; + } while (false); + return _hs[0]; + } + + private static int func_801__h13(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_55: { + label_56: { + label_57: { + label_58: { + switch(iL[2]) { + case 0: + { + break label_58; + } + case 1: + { + { + _hs[0] = 20001; + break _hb; + } + } + case 2: + { + { + _hs[0] = 20002; + break _hb; + } + } + case 3: + { + { + _hs[0] = 20003; + break _hb; + } + } + case 4: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 5: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 6: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 7: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 8: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 9: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 10: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 11: + { + break _hb; + } + case 12: + { + break label_56; + } + case 13: + { + break label_55; + } + default: + { + break label_57; + } + } + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3200, (long) 0L); + iL[3] = 1; + long[] callArgs_25 = new long[3]; + callArgs_25[2] = ((long) 16855); + callArgs_25[1] = ((long) (iL[4] + 3200)); + callArgs_25[0] = ((long) (iL[4] + 2936)); + long[] callResult_25 = instance.getMachine().call(803, callArgs_25); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_25[0])) != 0) { + { + _hs[0] = 30001; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3200); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3192, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[14] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 28); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1608, (long) lL[0]); + label_59: { + int ciTableIdx_26 = (int) (iL[14]); + int ciFuncId_26 = instance.table(0).requiredRef(ciTableIdx_26); + com.dylibso.chicory.runtime.Instance ciRefInstance_26 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_26), instance); + if (!ciRefInstance_26.type(ciRefInstance_26.functionType(ciFuncId_26)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_26 = new long[4]; + callArgs_26[3] = ((long) (iL[4] + 1608)); + callArgs_26[2] = ((long) iL[0]); + callArgs_26[1] = ((long) iL[5]); + callArgs_26[0] = ((long) iL[13]); + long[] callResult_26 = ciRefInstance_26.getMachine().call(ciFuncId_26, callArgs_26); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_26[0])) != 0) { + break label_59; + } + long[] callArgs_27 = new long[3]; + callArgs_27[2] = ((long) 0); + callArgs_27[1] = ((long) 23790); + callArgs_27[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_27); + { + _hs[0] = 30001; + break _hb; + } + } + iL[14] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 3045) & 0xFF); + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 3045, (byte) (1)); + iL[15] = ((iL[4] + 3168) + 8); + iL[16] = (iL[6] + 8); + memory.writeI32((int) iL[15] < 0 ? iL[15] : iL[15] + 0, (int) memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0)); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) memory.readLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0)); + iL[3] = 23858; + label_60: { + label_61: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_28 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 792)); + int ciFuncId_28 = instance.table(0).requiredRef(ciTableIdx_28); + com.dylibso.chicory.runtime.Instance ciRefInstance_28 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_28), instance); + if (!ciRefInstance_28.type(ciRefInstance_28.functionType(ciFuncId_28)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_28 = new long[2]; + callArgs_28[1] = ((long) iL[0]); + callArgs_28[0] = ((long) iL[13]); + long[] callResult_28 = ciRefInstance_28.getMachine().call(ciFuncId_28, callArgs_28); + if (((int) callResult_28[0]) != 0) { + break label_61; + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[17]); + iL[18] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[19] = memory.readInt((int) memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0) < 0 ? memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0) : memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0) + 796); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1600, (long) lL[0]); + iL[3] = 23900; + int ciTableIdx_29 = (int) (iL[19]); + int ciFuncId_29 = instance.table(0).requiredRef(ciTableIdx_29); + com.dylibso.chicory.runtime.Instance ciRefInstance_29 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_29), instance); + if (!ciRefInstance_29.type(ciRefInstance_29.functionType(ciFuncId_29)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_29 = new long[4]; + callArgs_29[3] = ((long) (iL[17] - iL[13])); + callArgs_29[2] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940))); + callArgs_29[1] = ((long) (iL[4] + 1600)); + callArgs_29[0] = ((long) iL[18]); + long[] callResult_29 = ciRefInstance_29.getMachine().call(ciFuncId_29, callArgs_29); + if (((int) callResult_29[0]) != 0) { + break label_61; + } + iL[3] = 23939; + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_30 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 800)); + int ciFuncId_30 = instance.table(0).requiredRef(ciTableIdx_30); + com.dylibso.chicory.runtime.Instance ciRefInstance_30 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_30), instance); + if (!ciRefInstance_30.type(ciRefInstance_30.functionType(ciFuncId_30)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_30 = new long[1]; + callArgs_30[0] = ((long) iL[13]); + long[] callResult_30 = ciRefInstance_30.getMachine().call(ciFuncId_30, callArgs_30); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_30[0])) != 0) { + break label_60; + } + } + long[] callArgs_31 = new long[3]; + callArgs_31[2] = ((long) 0); + callArgs_31[1] = ((long) iL[3]); + callArgs_31[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_31); + memory.writeI32((int) iL[16] < 0 ? iL[16] : iL[16] + 0, (int) memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0)); + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168)); + { + _hs[0] = 30002; + break _hb; + } + } + iL[17] = (int) (lL[0] >>> 32L); + iL[18] = (int) lL[0]; + memory.writeLong((int) iL[6] < 0 ? iL[6] : iL[6] + 0, (long) memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168)); + memory.writeI32((int) iL[16] < 0 ? iL[16] : iL[16] + 0, (int) memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0)); + label_62: { + label_63: { + label_64: { + label_65: { + int _d9 = func_801__h9(iL, lL, memory, instance); + if (_d9 == 1) + break label_62; + if (_d9 == 2) + break label_63; + if (_d9 == 3) + break label_64; + if (_d9 >= 10000) { + _hs[0] = ((_d9 - 10000)) + 10000; + break _hb; + } + } + long[] callArgs_141 = new long[3]; + callArgs_141[2] = ((long) 0); + callArgs_141[1] = ((long) 19808); + callArgs_141[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_141); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + long[] callArgs_142 = new long[3]; + callArgs_142[2] = ((long) 0); + callArgs_142[1] = ((long) 19704); + callArgs_142[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_142); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + long[] callArgs_143 = new long[3]; + callArgs_143[2] = ((long) 0); + callArgs_143[1] = ((long) 19521); + callArgs_143[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_143); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + long[] callArgs_144 = new long[3]; + callArgs_144[2] = ((long) 0); + callArgs_144[1] = ((long) 23623); + callArgs_144[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_144); + { + _hs[0] = 30002; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + { + _hs[0] = 30006; + break _hb; + } + } + { + _hs[0] = 30007; + break _hb; + } + } + label_146: { + if (((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 9) & 0xFF) != 0) { + break label_146; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2848, (int) 12); + long[] callArgs_145 = new long[3]; + callArgs_145[2] = ((long) (iL[4] + 2848)); + callArgs_145[1] = ((long) 5649); + callArgs_145[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_145); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + { + _hs[0] = 30008; + break _hb; + } + } + label_147: { + label_148: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_146 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 656)); + int ciFuncId_146 = instance.table(0).requiredRef(ciTableIdx_146); + com.dylibso.chicory.runtime.Instance ciRefInstance_146 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_146), instance); + if (!ciRefInstance_146.type(ciRefInstance_146.functionType(ciFuncId_146)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_146 = new long[2]; + callArgs_146[1] = ((long) iL[0]); + callArgs_146[0] = ((long) iL[3]); + long[] callResult_146 = ciRefInstance_146.getMachine().call(ciFuncId_146, callArgs_146); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_146[0])) != 0) { + break label_148; + } + long[] callArgs_147 = new long[3]; + callArgs_147[2] = ((long) 0); + callArgs_147[1] = ((long) 23465); + callArgs_147[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_147); + iL[3] = 1; + break label_147; + } + label_149: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_148 = new long[3]; + callArgs_148[2] = ((long) (iL[4] + 3168)); + callArgs_148[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_148[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_148 = instance.getMachine().call(177, callArgs_148); + iL[3] = ((int) callResult_148[0]); + if (iL[3] != 0) { + break label_149; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2864, (int) 6678); + long[] callArgs_149 = new long[3]; + callArgs_149[2] = ((long) (iL[4] + 2864)); + callArgs_149[1] = ((long) 11260); + callArgs_149[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_149); + iL[3] = 1; + break label_147; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3])); + label_150: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + int ciTableIdx_150 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 660)); + int ciFuncId_150 = instance.table(0).requiredRef(ciTableIdx_150); + com.dylibso.chicory.runtime.Instance ciRefInstance_150 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_150), instance); + if (!ciRefInstance_150.type(ciRefInstance_150.functionType(ciFuncId_150)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_150 = new long[2]; + callArgs_150[1] = ((long) iL[0]); + callArgs_150[0] = ((long) iL[3]); + long[] callResult_150 = ciRefInstance_150.getMachine().call(ciFuncId_150, callArgs_150); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_150[0])) != 0) { + break label_150; + } + long[] callArgs_151 = new long[3]; + callArgs_151[2] = ((long) 0); + callArgs_151[1] = ((long) 20160); + callArgs_151[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_151); + iL[3] = 1; + break label_147; + } + label_151: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_152 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 664)); + int ciFuncId_152 = instance.table(0).requiredRef(ciTableIdx_152); + com.dylibso.chicory.runtime.Instance ciRefInstance_152 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_152), instance); + if (!ciRefInstance_152.type(ciRefInstance_152.functionType(ciFuncId_152)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_152 = new long[1]; + callArgs_152[0] = ((long) iL[3]); + long[] callResult_152 = ciRefInstance_152.getMachine().call(ciFuncId_152, callArgs_152); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_152[0])) != 0) { + break label_151; + } + long[] callArgs_153 = new long[3]; + callArgs_153[2] = ((long) 0); + callArgs_153[1] = ((long) 23503); + callArgs_153[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_153); + iL[3] = 1; + break label_147; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3080, (int) iL[0]); + iL[3] = 0; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 30009; + break _hb; + } + } + label_152: { + if (((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 0) & 0xFF) != 0) { + break label_152; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2768, (int) 13); + long[] callArgs_154 = new long[3]; + callArgs_154[2] = ((long) (iL[4] + 2768)); + callArgs_154[1] = ((long) 5649); + callArgs_154[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_154); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[1]); + { + _hs[0] = 30008; + break _hb; + } + } + label_153: { + label_154: { + label_155: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_155 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 868)); + int ciFuncId_155 = instance.table(0).requiredRef(ciTableIdx_155); + com.dylibso.chicory.runtime.Instance ciRefInstance_155 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_155), instance); + if (!ciRefInstance_155.type(ciRefInstance_155.functionType(ciFuncId_155)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_155 = new long[2]; + callArgs_155[1] = ((long) iL[0]); + callArgs_155[0] = ((long) iL[3]); + long[] callResult_155 = ciRefInstance_155.getMachine().call(ciFuncId_155, callArgs_155); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_155[0])) != 0) { + break label_155; + } + long[] callArgs_156 = new long[3]; + callArgs_156[2] = ((long) 0); + callArgs_156[1] = ((long) 24249); + callArgs_156[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_156); + break label_154; + } + label_156: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_157 = new long[3]; + callArgs_157[2] = ((long) (iL[4] + 3168)); + callArgs_157[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_157[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_157 = instance.getMachine().call(177, callArgs_157); + iL[3] = ((int) callResult_157[0]); + if (iL[3] != 0) { + break label_156; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2784, (int) 6543); + long[] callArgs_158 = new long[3]; + callArgs_158[2] = ((long) (iL[4] + 2784)); + callArgs_158[1] = ((long) 11260); + callArgs_158[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_158); + break label_154; + } + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_157: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_157; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2808, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2804, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2800, (int) 6543); + long[] callArgs_159 = new long[3]; + callArgs_159[2] = ((long) (iL[4] + 2800)); + callArgs_159[1] = ((long) 12552); + callArgs_159[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_159); + break label_154; + } + label_158: { + label_159: { + label_160: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_160 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 872)); + int ciFuncId_160 = instance.table(0).requiredRef(ciTableIdx_160); + com.dylibso.chicory.runtime.Instance ciRefInstance_160 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_160), instance); + if (!ciRefInstance_160.type(ciRefInstance_160.functionType(ciFuncId_160)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_160 = new long[2]; + callArgs_160[1] = ((long) iL[3]); + callArgs_160[0] = ((long) iL[0]); + long[] callResult_160 = ciRefInstance_160.getMachine().call(ciFuncId_160, callArgs_160); + if (((int) callResult_160[0]) != 0) { + break label_160; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break label_158; + } + iL[14] = 0; + break label_159; + } + long[] callArgs_161 = new long[3]; + callArgs_161[2] = ((long) 0); + callArgs_161[1] = ((long) 19876); + callArgs_161[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_161); + break label_154; + } + label_161: while (true) { + label_162: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[0] = (iL[15] + 1); + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[0], iL[16]) != 0) { + break label_162; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2820, (int) 15538); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2816, (int) 7656); + long[] callArgs_162 = new long[3]; + callArgs_162[2] = ((long) (iL[4] + 2816)); + callArgs_162[1] = ((long) 10873); + callArgs_162[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_162); + break label_154; + } + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3064); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[15] = ((int) memory.read((int) (iL[13] + iL[15]) < 0 ? (iL[13] + iL[15]) : (iL[13] + iL[15]) + 0) & 0xFF); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_163: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[15]) != 0) { + break label_163; + } + long[] callArgs_163 = new long[3]; + callArgs_163[2] = ((long) 0); + callArgs_163[1] = ((long) 28739); + callArgs_163[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_163); + break label_154; + } + label_164: { + long[] callArgs_164 = new long[3]; + callArgs_164[2] = ((long) (iL[4] + 3168)); + callArgs_164[1] = ((long) (iL[13] + iL[16])); + callArgs_164[0] = ((long) (iL[13] + iL[0])); + long[] callResult_164 = instance.getMachine().call(177, callArgs_164); + iL[0] = ((int) callResult_164[0]); + if (iL[0] != 0) { + break label_164; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2832, (int) 1870); + long[] callArgs_165 = new long[3]; + callArgs_165[2] = ((long) (iL[4] + 2832)); + callArgs_165[1] = ((long) 11260); + callArgs_165[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_165); + break label_154; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[0])); + label_165: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_166 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 876)); + int ciFuncId_166 = instance.table(0).requiredRef(ciTableIdx_166); + com.dylibso.chicory.runtime.Instance ciRefInstance_166 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_166), instance); + if (!ciRefInstance_166.type(ciRefInstance_166.functionType(ciFuncId_166)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_166 = new long[3]; + callArgs_166[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168)); + callArgs_166[1] = ((long) (iL[14] + iL[17])); + callArgs_166[0] = ((long) iL[0]); + long[] callResult_166 = ciRefInstance_166.getMachine().call(ciFuncId_166, callArgs_166); + if (((int) callResult_166[0]) != 0) { + break label_165; + } + iL[14] = (iL[14] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[14], iL[3]) != 0) { + break label_158; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_161; + } + break; + } + long[] callArgs_167 = new long[3]; + callArgs_167[2] = ((long) 0); + callArgs_167[1] = ((long) 25252); + callArgs_167[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_167); + break label_154; + } + label_166: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_168 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 880)); + int ciFuncId_168 = instance.table(0).requiredRef(ciTableIdx_168); + com.dylibso.chicory.runtime.Instance ciRefInstance_168 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_168), instance); + if (!ciRefInstance_168.type(ciRefInstance_168.functionType(ciFuncId_168)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_168 = new long[1]; + callArgs_168[0] = ((long) iL[3]); + long[] callResult_168 = ciRefInstance_168.getMachine().call(ciFuncId_168, callArgs_168); + if (((int) callResult_168[0]) != 0) { + break label_166; + } + iL[3] = 0; + break label_153; + } + long[] callArgs_169 = new long[3]; + callArgs_169[2] = ((long) 0); + callArgs_169[1] = ((long) 24281); + callArgs_169[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_169); + } + iL[3] = 1; + } + iL[7] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, iL[7]) | iL[3]); + { + _hs[0] = 30009; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h11(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_117: { + label_118: { + label_119: { + label_120: { + label_121: { + label_122: { + label_123: { + label_124: { + int _d10 = func_804__h10(iL, lL, memory, instance); + if (_d10 == 1) + break label_123; + if (_d10 == 2) { + _hs[0] = 1; + break _hb; + } + if (_d10 == 3) { + _hs[0] = 2; + break _hb; + } + if (_d10 == 4) + break _hb; + if (_d10 == 5) { + _hs[0] = 3; + break _hb; + } + if (_d10 == 6) + break label_117; + if (_d10 == 7) { + _hs[0] = 4; + break _hb; + } + if (_d10 == 8) + break label_122; + if (_d10 == 9) + break label_121; + if (_d10 == 10) + break label_120; + if (_d10 == 11) + break label_119; + if (_d10 == 12) + break label_118; + if (_d10 >= 10000) { + _hs[0] = ((_d10 - 10000)) + 10000; + break _hb; + } + } + label_164: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_67 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 360)); + int ciFuncId_67 = instance.table(0).requiredRef(ciTableIdx_67); + com.dylibso.chicory.runtime.Instance ciRefInstance_67 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_67), instance); + if (!ciRefInstance_67.type(ciRefInstance_67.functionType(ciFuncId_67)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_67 = new long[1]; + callArgs_67[0] = ((long) iL[4]); + long[] callResult_67 = ciRefInstance_67.getMachine().call(ciFuncId_67, callArgs_67); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_67[0])) != 0) { + break label_164; + } + long[] callArgs_68 = new long[3]; + callArgs_68[2] = ((long) 0); + callArgs_68[1] = ((long) 21578); + callArgs_68[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_68); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_69 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_69 = instance.table(0).requiredRef(ciTableIdx_69); + com.dylibso.chicory.runtime.Instance ciRefInstance_69 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_69), instance); + if (!ciRefInstance_69.type(ciRefInstance_69.functionType(ciFuncId_69)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_69 = new long[1]; + callArgs_69[0] = ((long) iL[4]); + long[] callResult_69 = ciRefInstance_69.getMachine().call(ciFuncId_69, callArgs_69); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_69[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + long[] callArgs_70 = new long[3]; + callArgs_70[2] = ((long) 0); + callArgs_70[1] = ((long) 25128); + callArgs_70[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_70); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + label_165: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_71 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 368)); + int ciFuncId_71 = instance.table(0).requiredRef(ciTableIdx_71); + com.dylibso.chicory.runtime.Instance ciRefInstance_71 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_71), instance); + if (!ciRefInstance_71.type(ciRefInstance_71.functionType(ciFuncId_71)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_71 = new long[1]; + callArgs_71[0] = ((long) iL[4]); + long[] callResult_71 = ciRefInstance_71.getMachine().call(ciFuncId_71, callArgs_71); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_71[0])) != 0) { + break label_165; + } + long[] callArgs_72 = new long[3]; + callArgs_72[2] = ((long) 0); + callArgs_72[1] = ((long) 22779); + callArgs_72[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_72); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + if (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 476) != 0) { + { + _hs[0] = 30015; + break _hb; + } + } + iL[11] = 0; + { + _hs[0] = 30007; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_73 = new long[3]; + callArgs_73[2] = ((long) 15360); + callArgs_73[1] = ((long) (iL[3] + 352)); + callArgs_73[0] = ((long) iL[0]); + long[] callResult_73 = instance.getMachine().call(815, callArgs_73); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_73[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_166: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_74 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 392)); + int ciFuncId_74 = instance.table(0).requiredRef(ciTableIdx_74); + com.dylibso.chicory.runtime.Instance ciRefInstance_74 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_74), instance); + if (!ciRefInstance_74.type(ciRefInstance_74.functionType(ciFuncId_74)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_74 = new long[2]; + callArgs_74[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352)); + callArgs_74[0] = ((long) iL[4]); + long[] callResult_74 = ciRefInstance_74.getMachine().call(ciFuncId_74, callArgs_74); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_74[0])) != 0) { + break label_166; + } + iL[4] = 20808; + { + _hs[0] = 30016; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_75 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 232)); + int ciFuncId_75 = instance.table(0).requiredRef(ciTableIdx_75); + com.dylibso.chicory.runtime.Instance ciRefInstance_75 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_75), instance); + if (!ciRefInstance_75.type(ciRefInstance_75.functionType(ciFuncId_75)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_75 = new long[2]; + callArgs_75[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352)); + callArgs_75[0] = ((long) iL[4]); + long[] callResult_75 = ciRefInstance_75.getMachine().call(ciFuncId_75, callArgs_75); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_75[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 25792; + { + _hs[0] = 30016; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_76 = new long[2]; + callArgs_76[1] = ((long) (iL[3] + 352)); + callArgs_76[0] = ((long) iL[0]); + long[] callResult_76 = instance.getMachine().call(823, callArgs_76); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_76[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_167: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_77 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 396)); + int ciFuncId_77 = instance.table(0).requiredRef(ciTableIdx_77); + com.dylibso.chicory.runtime.Instance ciRefInstance_77 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_77), instance); + if (!ciRefInstance_77.type(ciRefInstance_77.functionType(ciFuncId_77)).typesMatch(instance.type(10))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_77 = new long[2]; + callArgs_77[1] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + callArgs_77[0] = ((long) iL[4]); + long[] callResult_77 = ciRefInstance_77.getMachine().call(ciFuncId_77, callArgs_77); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_77[0])) != 0) { + break label_167; + } + iL[4] = 20746; + { + _hs[0] = 30017; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_78 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 256)); + int ciFuncId_78 = instance.table(0).requiredRef(ciTableIdx_78); + com.dylibso.chicory.runtime.Instance ciRefInstance_78 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_78), instance); + if (!ciRefInstance_78.type(ciRefInstance_78.functionType(ciFuncId_78)).typesMatch(instance.type(10))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_78 = new long[2]; + callArgs_78[1] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + callArgs_78[0] = ((long) iL[4]); + long[] callResult_78 = ciRefInstance_78.getMachine().call(ciFuncId_78, callArgs_78); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_78[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 25733; + { + _hs[0] = 30017; + break _hb; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 352, (int) 0); + iL[11] = 1; + long[] callArgs_79 = new long[2]; + callArgs_79[1] = ((long) (iL[3] + 352)); + callArgs_79[0] = ((long) iL[0]); + long[] callResult_79 = instance.getMachine().call(824, callArgs_79); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_79[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_168: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_80 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 372)); + int ciFuncId_80 = instance.table(0).requiredRef(ciTableIdx_80); + com.dylibso.chicory.runtime.Instance ciRefInstance_80 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_80), instance); + if (!ciRefInstance_80.type(ciRefInstance_80.functionType(ciFuncId_80)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_80 = new long[2]; + callArgs_80[1] = ((long) iL[12]); + callArgs_80[0] = ((long) iL[4]); + long[] callResult_80 = ciRefInstance_80.getMachine().call(ciFuncId_80, callArgs_80); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_80[0])) != 0) { + break label_168; + } + iL[4] = 20839; + { + _hs[0] = 30018; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_81 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 260)); + int ciFuncId_81 = instance.table(0).requiredRef(ciTableIdx_81); + com.dylibso.chicory.runtime.Instance ciRefInstance_81 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_81), instance); + if (!ciRefInstance_81.type(ciRefInstance_81.functionType(ciFuncId_81)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_81 = new long[2]; + callArgs_81[1] = ((long) iL[12]); + callArgs_81[0] = ((long) iL[4]); + long[] callResult_81 = ciRefInstance_81.getMachine().call(ciFuncId_81, callArgs_81); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_81[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 25952; + { + _hs[0] = 30018; + break _hb; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352, (long) 0L); + iL[11] = 1; + long[] callArgs_82 = new long[2]; + callArgs_82[1] = ((long) (iL[3] + 352)); + callArgs_82[0] = ((long) iL[0]); + long[] callResult_82 = instance.getMachine().call(825, callArgs_82); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_82[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_169: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_83 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 376)); + int ciFuncId_83 = instance.table(0).requiredRef(ciTableIdx_83); + com.dylibso.chicory.runtime.Instance ciRefInstance_83 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_83), instance); + if (!ciRefInstance_83.type(ciRefInstance_83.functionType(ciFuncId_83)).typesMatch(instance.type(10))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_83 = new long[2]; + callArgs_83[1] = lL[0]; + callArgs_83[0] = ((long) iL[4]); + long[] callResult_83 = ciRefInstance_83.getMachine().call(ciFuncId_83, callArgs_83); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_83[0])) != 0) { + break label_169; + } + iL[4] = 20777; + { + _hs[0] = 30019; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_84 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 264)); + int ciFuncId_84 = instance.table(0).requiredRef(ciTableIdx_84); + com.dylibso.chicory.runtime.Instance ciRefInstance_84 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_84), instance); + if (!ciRefInstance_84.type(ciRefInstance_84.functionType(ciFuncId_84)).typesMatch(instance.type(10))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_84 = new long[2]; + callArgs_84[1] = lL[0]; + callArgs_84[0] = ((long) iL[4]); + long[] callResult_84 = ciRefInstance_84.getMachine().call(ciFuncId_84, callArgs_84); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_84[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 25764; + { + _hs[0] = 30019; + break _hb; + } + } + iL[4] = ((iL[3] + 352) + 8); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (long) 0L); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352, (long) 0L); + iL[11] = 1; + long[] callArgs_85 = new long[3]; + callArgs_85[2] = ((long) 15311); + callArgs_85[1] = ((long) (iL[3] + 352)); + callArgs_85[0] = ((long) iL[0]); + long[] callResult_85 = instance.getMachine().call(826, callArgs_85); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_85[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[10] = memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 380); + memory.writeLong((int) ((iL[3] + 144) + 8) < 0 ? ((iL[3] + 144) + 8) : ((iL[3] + 144) + 8) + 0, (long) memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 0)); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 144, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352)); + label_170: { + int ciTableIdx_86 = (int) (iL[10]); + int ciFuncId_86 = instance.table(0).requiredRef(ciTableIdx_86); + com.dylibso.chicory.runtime.Instance ciRefInstance_86 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_86), instance); + if (!ciRefInstance_86.type(ciRefInstance_86.functionType(ciFuncId_86)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_86 = new long[2]; + callArgs_86[1] = ((long) (iL[3] + 144)); + callArgs_86[0] = ((long) iL[12]); + long[] callResult_86 = ciRefInstance_86.getMachine().call(ciFuncId_86, callArgs_86); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_86[0])) != 0) { + break label_170; + } + iL[4] = 20714; + { + _hs[0] = 30020; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 268); + memory.writeLong((int) ((iL[3] + 128) + 8) < 0 ? ((iL[3] + 128) + 8) : ((iL[3] + 128) + 8) + 0, (long) memory.readLong((int) ((iL[3] + 352) + 8) < 0 ? ((iL[3] + 352) + 8) : ((iL[3] + 352) + 8) + 0)); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 128, (long) memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352)); + int ciTableIdx_87 = (int) (iL[12]); + int ciFuncId_87 = instance.table(0).requiredRef(ciTableIdx_87); + com.dylibso.chicory.runtime.Instance ciRefInstance_87 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_87), instance); + if (!ciRefInstance_87.type(ciRefInstance_87.functionType(ciFuncId_87)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_87 = new long[2]; + callArgs_87[1] = ((long) (iL[3] + 128)); + callArgs_87[0] = ((long) iL[4]); + long[] callResult_87 = ciRefInstance_87.getMachine().call(ciFuncId_87, callArgs_87); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_87[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 25704; + { + _hs[0] = 30020; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_88 = new long[3]; + callArgs_88[2] = ((long) 1751); + callArgs_88[1] = ((long) (iL[3] + 352)); + callArgs_88[0] = ((long) iL[0]); + long[] callResult_88 = instance.getMachine().call(814, callArgs_88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_88[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_171: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_89 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 384)); + int ciFuncId_89 = instance.table(0).requiredRef(ciTableIdx_89); + com.dylibso.chicory.runtime.Instance ciRefInstance_89 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_89), instance); + if (!ciRefInstance_89.type(ciRefInstance_89.functionType(ciFuncId_89)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_89 = new long[2]; + callArgs_89[1] = ((long) iL[12]); + callArgs_89[0] = ((long) iL[4]); + long[] callResult_89 = ciRefInstance_89.getMachine().call(ciFuncId_89, callArgs_89); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_89[0])) != 0) { + break label_171; + } + iL[4] = 21353; + { + _hs[0] = 30021; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_90 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_90 = instance.table(0).requiredRef(ciTableIdx_90); + com.dylibso.chicory.runtime.Instance ciRefInstance_90 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_90), instance); + if (!ciRefInstance_90.type(ciRefInstance_90.functionType(ciFuncId_90)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_90 = new long[2]; + callArgs_90[1] = ((long) iL[12]); + callArgs_90[0] = ((long) iL[4]); + long[] callResult_90 = ciRefInstance_90.getMachine().call(ciFuncId_90, callArgs_90); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_90[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 30021; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h14(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_462: { + label_463: { + switch((memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3144) + -5)) { + case 0: + { + break label_462; + } + case 1: + { + { + _hs[0] = 1; + break _hb; + } + } + case 2: + { + { + _hs[0] = 2; + break _hb; + } + } + case 3: + { + break label_463; + } + default: + { + break _hb; + } + } + } + label_464: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_499 = new long[3]; + callArgs_499[2] = ((long) (iL[4] + 3136)); + callArgs_499[1] = ((long) (iL[15] + iL[3])); + callArgs_499[0] = ((long) (iL[15] + iL[13])); + long[] callResult_499 = instance.getMachine().call(177, callArgs_499); + iL[13] = ((int) callResult_499[0]); + if (iL[13] != 0) { + break label_464; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 944, (int) 6412); + long[] callArgs_500 = new long[3]; + callArgs_500[2] = ((long) (iL[4] + 944)); + callArgs_500[1] = ((long) 11260); + callArgs_500[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_500); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 20002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_501 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 808)); + int ciFuncId_501 = instance.table(0).requiredRef(ciTableIdx_501); + com.dylibso.chicory.runtime.Instance ciRefInstance_501 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_501), instance); + if (!ciRefInstance_501.type(ciRefInstance_501.functionType(ciFuncId_501)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_501 = new long[2]; + callArgs_501[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136)); + callArgs_501[0] = ((long) iL[13]); + long[] callResult_501 = ciRefInstance_501.getMachine().call(ciFuncId_501, callArgs_501); + if (((int) callResult_501[0]) != 0) { + { + _hs[0] = 20013; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136)) != 0) { + { + _hs[0] = 10000; + break _hb; + } + } + iL[15] = 0; + label_465: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3160, (int) 0); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3128, (int) 0); + label_466: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_502 = new long[3]; + callArgs_502[2] = ((long) (iL[4] + 3128)); + callArgs_502[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_502[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_502 = instance.getMachine().call(177, callArgs_502); + iL[16] = ((int) callResult_502[0]); + if (iL[16] != 0) { + break label_466; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 960, (int) 15879); + long[] callArgs_503 = new long[3]; + callArgs_503[2] = ((long) (iL[4] + 960)); + callArgs_503[1] = ((long) 11260); + callArgs_503[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_503); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 20002; + break _hb; + } + } + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[16] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[16]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[16]); + label_467: { + long[] callArgs_504 = new long[3]; + callArgs_504[2] = ((long) (iL[4] + 3160)); + callArgs_504[1] = ((long) (iL[13] + iL[17])); + callArgs_504[0] = ((long) (iL[13] + iL[16])); + long[] callResult_504 = instance.getMachine().call(177, callArgs_504); + iL[13] = ((int) callResult_504[0]); + if (iL[13] != 0) { + break label_467; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 976, (int) 8286); + long[] callArgs_505 = new long[3]; + callArgs_505[2] = ((long) (iL[4] + 976)); + callArgs_505[1] = ((long) 11260); + callArgs_505[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_505); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 20002; + break _hb; + } + } + iL[16] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[16]); + label_468: { + int _d19 = func_801__h19(iL, lL, memory, instance); + if (_d19 >= 10000) { + _hs[0] = (_d19 - 10000); + break _hb; + } + } + iL[15] = (iL[15] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[15], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_465; + } + { + _hs[0] = 10000; + break _hb; + } + } + } + label_483: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_531 = new long[3]; + callArgs_531[2] = ((long) (iL[4] + 3136)); + callArgs_531[1] = ((long) (iL[15] + iL[3])); + callArgs_531[0] = ((long) (iL[15] + iL[13])); + long[] callResult_531 = instance.getMachine().call(177, callArgs_531); + iL[13] = ((int) callResult_531[0]); + if (iL[13] != 0) { + break label_483; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1104, (int) 6345); + long[] callArgs_532 = new long[3]; + callArgs_532[2] = ((long) (iL[4] + 1104)); + callArgs_532[1] = ((long) 11260); + callArgs_532[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_532); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 20002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + label_484: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_533 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 836)); + int ciFuncId_533 = instance.table(0).requiredRef(ciTableIdx_533); + com.dylibso.chicory.runtime.Instance ciRefInstance_533 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_533), instance); + if (!ciRefInstance_533.type(ciRefInstance_533.functionType(ciFuncId_533)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_533 = new long[2]; + callArgs_533[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136)); + callArgs_533[0] = ((long) iL[13]); + long[] callResult_533 = ciRefInstance_533.getMachine().call(ciFuncId_533, callArgs_533); + if (((int) callResult_533[0]) != 0) { + break label_484; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136)) != 0) { + { + _hs[0] = 10000; + break _hb; + } + } + iL[13] = 0; + label_485: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_534 = new long[3]; + callArgs_534[2] = ((long) 16809); + callArgs_534[1] = ((long) (iL[4] + 3168)); + callArgs_534[0] = ((long) (iL[4] + 2936)); + long[] callResult_534 = instance.getMachine().call(803, callArgs_534); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_534[0])) != 0) { + { + _hs[0] = 20014; + break _hb; + } + } + label_486: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_535 = new long[3]; + callArgs_535[2] = ((long) (iL[4] + 3160)); + callArgs_535[1] = ((long) (iL[15] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_535[0] = ((long) (iL[15] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_535 = instance.getMachine().call(177, callArgs_535); + iL[15] = ((int) callResult_535[0]); + if (iL[15] != 0) { + break label_486; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1120, (int) 6828); + long[] callArgs_536 = new long[3]; + callArgs_536[2] = ((long) (iL[4] + 1120)); + callArgs_536[1] = ((long) 11260); + callArgs_536[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_536); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 20002; + break _hb; + } + } + iL[16] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[16]); + label_487: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[15], 32) != 0) { + break label_487; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1140, (int) iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1136, (int) 6828); + long[] callArgs_537 = new long[3]; + callArgs_537[2] = ((long) (iL[4] + 1136)); + callArgs_537[1] = ((long) 5501); + callArgs_537[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_537); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 20002; + break _hb; + } + } + label_488: { + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_538 = new long[3]; + callArgs_538[2] = ((long) (iL[4] + 3128)); + callArgs_538[1] = ((long) (iL[17] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_538[0] = ((long) (iL[17] + iL[16])); + long[] callResult_538 = instance.getMachine().call(177, callArgs_538); + iL[16] = ((int) callResult_538[0]); + if (iL[16] != 0) { + break label_488; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1152, (int) 8272); + long[] callArgs_539 = new long[3]; + callArgs_539[2] = ((long) (iL[4] + 1152)); + callArgs_539[1] = ((long) 11260); + callArgs_539[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_539); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 20002; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3216, (long) lL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[16])); + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[17] = memory.readInt((int) memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) < 0 ? memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) : memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) + 840); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1160, (long) lL[0]); + label_489: { + int ciTableIdx_540 = (int) (iL[17]); + int ciFuncId_540 = instance.table(0).requiredRef(ciTableIdx_540); + com.dylibso.chicory.runtime.Instance ciRefInstance_540 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_540), instance); + if (!ciRefInstance_540.type(ciRefInstance_540.functionType(ciFuncId_540)).typesMatch(instance.type(13))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_540 = new long[5]; + callArgs_540[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3128)); + callArgs_540[3] = com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(iL[15]); + callArgs_540[2] = ((long) (iL[4] + 1160)); + callArgs_540[1] = ((long) iL[13]); + callArgs_540[0] = ((long) iL[16]); + long[] callResult_540 = ciRefInstance_540.getMachine().call(ciFuncId_540, callArgs_540); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_540[0])) != 0) { + break label_489; + } + long[] callArgs_541 = new long[3]; + callArgs_541[2] = ((long) 0); + callArgs_541[1] = ((long) 22895); + callArgs_541[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_541); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 20002; + break _hb; + } + } + iL[13] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[13], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3136)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_485; + } + { + _hs[0] = 10000; + break _hb; + } + } + } + long[] callArgs_542 = new long[3]; + callArgs_542[2] = ((long) 0); + callArgs_542[1] = ((long) 19601); + callArgs_542[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_542); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 20002; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h15(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_222: { + label_223: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_231 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 580)); + int ciFuncId_231 = instance.table(0).requiredRef(ciTableIdx_231); + com.dylibso.chicory.runtime.Instance ciRefInstance_231 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_231), instance); + if (!ciRefInstance_231.type(ciRefInstance_231.functionType(ciFuncId_231)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_231 = new long[2]; + callArgs_231[1] = ((long) iL[0]); + callArgs_231[0] = ((long) iL[3]); + long[] callResult_231 = ciRefInstance_231.getMachine().call(ciFuncId_231, callArgs_231); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_231[0])) != 0) { + break label_223; + } + long[] callArgs_232 = new long[3]; + callArgs_232[2] = ((long) 0); + callArgs_232[1] = ((long) 23979); + callArgs_232[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_232); + break label_222; + } + label_224: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_233 = new long[3]; + callArgs_233[2] = ((long) (iL[4] + 3168)); + callArgs_233[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_233[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_233 = instance.getMachine().call(177, callArgs_233); + iL[3] = ((int) callResult_233[0]); + if (iL[3] != 0) { + break label_224; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2336, (int) 6238); + long[] callArgs_234 = new long[3]; + callArgs_234[2] = ((long) (iL[4] + 2336)); + callArgs_234[1] = ((long) 11260); + callArgs_234[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_234); + break label_222; + } + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[0]); + label_225: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[0] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_225; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2360, (int) iL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2356, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2352, (int) 6238); + long[] callArgs_235 = new long[3]; + callArgs_235[2] = ((long) (iL[4] + 2352)); + callArgs_235[1] = ((long) 12552); + callArgs_235[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_235); + break label_222; + } + label_226: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_236 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 584)); + int ciFuncId_236 = instance.table(0).requiredRef(ciTableIdx_236); + com.dylibso.chicory.runtime.Instance ciRefInstance_236 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_236), instance); + if (!ciRefInstance_236.type(ciRefInstance_236.functionType(ciFuncId_236)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_236 = new long[2]; + callArgs_236[1] = ((long) iL[3]); + callArgs_236[0] = ((long) iL[0]); + long[] callResult_236 = ciRefInstance_236.getMachine().call(ciFuncId_236, callArgs_236); + if (((int) callResult_236[0]) != 0) { + break label_226; + } + label_227: { + int _d20 = func_801__h20(iL, lL, memory, instance); + if (_d20 == 1) + break label_222; + if (_d20 >= 10000) { + _hs[0] = (_d20 - 10000); + break _hb; + } + } + label_260: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_280 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 620)); + int ciFuncId_280 = instance.table(0).requiredRef(ciTableIdx_280); + com.dylibso.chicory.runtime.Instance ciRefInstance_280 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_280), instance); + if (!ciRefInstance_280.type(ciRefInstance_280.functionType(ciFuncId_280)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_280 = new long[1]; + callArgs_280[0] = ((long) iL[3]); + long[] callResult_280 = ciRefInstance_280.getMachine().call(ciFuncId_280, callArgs_280); + if (((int) callResult_280[0]) != 0) { + break label_260; + } + iL[3] = 0; + break _hb; + } + long[] callArgs_281 = new long[3]; + callArgs_281[2] = ((long) 0); + callArgs_281[1] = ((long) 24012); + callArgs_281[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_281); + break label_222; + } + long[] callArgs_282 = new long[3]; + callArgs_282[2] = ((long) 0); + callArgs_282[1] = ((long) 19421); + callArgs_282[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_282); + } + iL[3] = 1; + } while (false); + return _hs[0]; + } + + private static int func_804__h12(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_105: { + label_106: { + label_107: { + label_108: { + label_109: { + label_110: { + label_111: { + int _d5 = func_804__h5(iL, lL, memory, instance); + if (_d5 == 1) + break label_110; + if (_d5 == 2) + break label_109; + if (_d5 == 3) + break label_108; + if (_d5 == 4) + break label_107; + if (_d5 == 5) + break label_106; + if (_d5 == 6) + break label_105; + if (_d5 == 7) { + _hs[0] = 10001; + break _hb; + } + if (_d5 == 8) { + _hs[0] = 1; + break _hb; + } + if (_d5 == 9) { + _hs[0] = 2; + break _hb; + } + if (_d5 == 10) { + _hs[0] = 3; + break _hb; + } + if (_d5 == 11) { + _hs[0] = 10002; + break _hb; + } + if (_d5 == 12) { + _hs[0] = 10003; + break _hb; + } + if (_d5 == 13) { + _hs[0] = 10000; + break _hb; + } + if (_d5 == 14) { + _hs[0] = 4; + break _hb; + } + if (_d5 == 15) { + _hs[0] = 10004; + break _hb; + } + if (_d5 == 16) { + _hs[0] = 10005; + break _hb; + } + if (_d5 == 17) { + _hs[0] = 10006; + break _hb; + } + if (_d5 >= 10000) { + _hs[0] = (((_d5 - 10000)) + 10000) + 10000; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_111 = new long[3]; + callArgs_111[2] = ((long) 13284); + callArgs_111[1] = ((long) (iL[3] + 352)); + callArgs_111[0] = ((long) iL[0]); + long[] callResult_111 = instance.getMachine().call(814, callArgs_111); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_111[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_181: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_112 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 504)); + int ciFuncId_112 = instance.table(0).requiredRef(ciTableIdx_112); + com.dylibso.chicory.runtime.Instance ciRefInstance_112 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_112), instance); + if (!ciRefInstance_112.type(ciRefInstance_112.functionType(ciFuncId_112)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_112 = new long[2]; + callArgs_112[1] = ((long) iL[12]); + callArgs_112[0] = ((long) iL[4]); + long[] callResult_112 = ciRefInstance_112.getMachine().call(ciFuncId_112, callArgs_112); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_112[0])) != 0) { + break label_181; + } + iL[4] = 22034; + { + _hs[0] = 30026; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_113 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_113 = instance.table(0).requiredRef(ciTableIdx_113); + com.dylibso.chicory.runtime.Instance ciRefInstance_113 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_113), instance); + if (!ciRefInstance_113.type(ciRefInstance_113.functionType(ciFuncId_113)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_113 = new long[2]; + callArgs_113[1] = ((long) iL[12]); + callArgs_113[0] = ((long) iL[4]); + long[] callResult_113 = ciRefInstance_113.getMachine().call(ciFuncId_113, callArgs_113); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_113[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 30026; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_114 = new long[3]; + callArgs_114[2] = ((long) 7371); + callArgs_114[1] = ((long) (iL[3] + 352)); + callArgs_114[0] = ((long) iL[0]); + long[] callResult_114 = instance.getMachine().call(814, callArgs_114); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_114[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 336, (int) 0); + label_182: { + label_183: { + label_184: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) < 0 ? memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) : memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) + 10) & 0xFF)) != 0) { + break label_184; + } + long[] callArgs_115 = new long[3]; + callArgs_115[2] = ((long) 2030); + callArgs_115[1] = ((long) (iL[3] + 336)); + callArgs_115[0] = ((long) iL[0]); + long[] callResult_115 = instance.getMachine().call(814, callArgs_115); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_115[0])) != 0) { + break label_182; + } + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + break label_183; + } + long[] callArgs_116 = new long[3]; + callArgs_116[2] = ((long) 18703); + callArgs_116[1] = ((long) (iL[3] + 348)); + callArgs_116[0] = ((long) iL[0]); + long[] callResult_116 = instance.getMachine().call(811, callArgs_116); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_116[0])) != 0) { + break label_182; + } + label_185: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 348) & 0xFF)) != 0) { + break label_185; + } + long[] callArgs_117 = new long[3]; + callArgs_117[2] = ((long) 0); + callArgs_117[1] = ((long) 28619); + callArgs_117[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_117); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + iL[4] = 0; + } + label_186: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[11] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_118 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 508)); + int ciFuncId_118 = instance.table(0).requiredRef(ciTableIdx_118); + com.dylibso.chicory.runtime.Instance ciRefInstance_118 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_118), instance); + if (!ciRefInstance_118.type(ciRefInstance_118.functionType(ciFuncId_118)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_118 = new long[3]; + callArgs_118[2] = ((long) iL[4]); + callArgs_118[1] = ((long) iL[11]); + callArgs_118[0] = ((long) iL[12]); + long[] callResult_118 = ciRefInstance_118.getMachine().call(ciFuncId_118, callArgs_118); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_118[0])) != 0) { + break label_186; + } + long[] callArgs_119 = new long[3]; + callArgs_119[2] = ((long) 0); + callArgs_119[1] = ((long) 21416); + callArgs_119[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_119); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_120 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 244)); + int ciFuncId_120 = instance.table(0).requiredRef(ciTableIdx_120); + com.dylibso.chicory.runtime.Instance ciRefInstance_120 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_120), instance); + if (!ciRefInstance_120.type(ciRefInstance_120.functionType(ciFuncId_120)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_120 = new long[3]; + callArgs_120[2] = ((long) iL[4]); + callArgs_120[1] = ((long) iL[11]); + callArgs_120[0] = ((long) iL[12]); + long[] callResult_120 = ciRefInstance_120.getMachine().call(ciFuncId_120, callArgs_120); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_120[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + long[] callArgs_121 = new long[3]; + callArgs_121[2] = ((long) 0); + callArgs_121[1] = ((long) 25823); + callArgs_121[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_121); + } + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_122 = new long[3]; + callArgs_122[2] = ((long) 1685); + callArgs_122[1] = ((long) (iL[3] + 352)); + callArgs_122[0] = ((long) iL[0]); + long[] callResult_122 = instance.getMachine().call(814, callArgs_122); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_122[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_187: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_123 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 416)); + int ciFuncId_123 = instance.table(0).requiredRef(ciTableIdx_123); + com.dylibso.chicory.runtime.Instance ciRefInstance_123 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_123), instance); + if (!ciRefInstance_123.type(ciRefInstance_123.functionType(ciFuncId_123)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_123 = new long[2]; + callArgs_123[1] = ((long) iL[12]); + callArgs_123[0] = ((long) iL[4]); + long[] callResult_123 = ciRefInstance_123.getMachine().call(ciFuncId_123, callArgs_123); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_123[0])) != 0) { + break label_187; + } + iL[4] = 22714; + { + _hs[0] = 30027; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_124 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_124 = instance.table(0).requiredRef(ciTableIdx_124); + com.dylibso.chicory.runtime.Instance ciRefInstance_124 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_124), instance); + if (!ciRefInstance_124.type(ciRefInstance_124.functionType(ciFuncId_124)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_124 = new long[2]; + callArgs_124[1] = ((long) iL[12]); + callArgs_124[0] = ((long) iL[4]); + long[] callResult_124 = ciRefInstance_124.getMachine().call(ciFuncId_124, callArgs_124); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_124[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 30027; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_125 = new long[8]; + callArgs_125[7] = ((long) 0); + callArgs_125[6] = ((long) 7265); + callArgs_125[5] = ((long) 2411); + callArgs_125[4] = ((long) 6877); + callArgs_125[3] = ((long) (iL[3] + 336)); + callArgs_125[2] = ((long) (iL[3] + 348)); + callArgs_125[1] = ((long) (iL[3] + 352)); + callArgs_125[0] = ((long) iL[0]); + long[] callResult_125 = instance.getMachine().call(827, callArgs_125); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_125[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_188: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_126 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 404)); + int ciFuncId_126 = instance.table(0).requiredRef(ciTableIdx_126); + com.dylibso.chicory.runtime.Instance ciRefInstance_126 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_126), instance); + if (!ciRefInstance_126.type(ciRefInstance_126.functionType(ciFuncId_126)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_126 = new long[5]; + callArgs_126[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_126[3] = lL[0]; + callArgs_126[2] = ((long) iL[4]); + callArgs_126[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_126[0] = ((long) iL[12]); + long[] callResult_126 = ciRefInstance_126.getMachine().call(ciFuncId_126, callArgs_126); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_126[0])) != 0) { + break label_188; + } + iL[4] = 22805; + { + _hs[0] = 30028; + break _hb; + } + } + iL[12] = (int) lL[0]; + iL[10] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[14] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[13] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + label_189: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_189; + } + int ciTableIdx_127 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 248)); + int ciFuncId_127 = instance.table(0).requiredRef(ciTableIdx_127); + com.dylibso.chicory.runtime.Instance ciRefInstance_127 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_127), instance); + if (!ciRefInstance_127.type(ciRefInstance_127.functionType(ciFuncId_127)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_127 = new long[4]; + callArgs_127[3] = ((long) iL[13]); + callArgs_127[2] = ((long) iL[4]); + callArgs_127[1] = ((long) iL[12]); + callArgs_127[0] = ((long) iL[10]); + long[] callResult_127 = ciRefInstance_127.getMachine().call(ciFuncId_127, callArgs_127); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_127[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 25860; + { + _hs[0] = 30028; + break _hb; + } + } + int ciTableIdx_128 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 244)); + int ciFuncId_128 = instance.table(0).requiredRef(ciTableIdx_128); + com.dylibso.chicory.runtime.Instance ciRefInstance_128 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_128), instance); + if (!ciRefInstance_128.type(ciRefInstance_128.functionType(ciFuncId_128)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_128 = new long[3]; + callArgs_128[2] = ((long) iL[13]); + callArgs_128[1] = ((long) iL[12]); + callArgs_128[0] = ((long) iL[10]); + long[] callResult_128 = ciRefInstance_128.getMachine().call(ciFuncId_128, callArgs_128); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_128[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 25823; + { + _hs[0] = 30028; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_129 = new long[8]; + callArgs_129[7] = ((long) 0); + callArgs_129[6] = ((long) 7240); + callArgs_129[5] = ((long) 2398); + callArgs_129[4] = ((long) 6861); + callArgs_129[3] = ((long) (iL[3] + 336)); + callArgs_129[2] = ((long) (iL[3] + 348)); + callArgs_129[1] = ((long) (iL[3] + 352)); + callArgs_129[0] = ((long) iL[0]); + long[] callResult_129 = instance.getMachine().call(827, callArgs_129); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_129[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_190: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348); + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_130 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 516)); + int ciFuncId_130 = instance.table(0).requiredRef(ciTableIdx_130); + com.dylibso.chicory.runtime.Instance ciRefInstance_130 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_130), instance); + if (!ciRefInstance_130.type(ciRefInstance_130.functionType(ciFuncId_130)).typesMatch(instance.type(14))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_130 = new long[5]; + callArgs_130[4] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + callArgs_130[3] = lL[0]; + callArgs_130[2] = ((long) iL[4]); + callArgs_130[1] = ((long) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 448)); + callArgs_130[0] = ((long) iL[12]); + long[] callResult_130 = ciRefInstance_130.getMachine().call(ciFuncId_130, callArgs_130); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_130[0])) != 0) { + break label_190; + } + iL[4] = 22456; + { + _hs[0] = 30029; + break _hb; + } + } + iL[12] = (int) lL[0]; + iL[10] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[14] = memory.readInt((int) iL[10] < 0 ? iL[10] : iL[10] + 0); + iL[13] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + label_191: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_191; + } + int ciTableIdx_131 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 248)); + int ciFuncId_131 = instance.table(0).requiredRef(ciTableIdx_131); + com.dylibso.chicory.runtime.Instance ciRefInstance_131 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_131), instance); + if (!ciRefInstance_131.type(ciRefInstance_131.functionType(ciFuncId_131)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_131 = new long[4]; + callArgs_131[3] = ((long) iL[13]); + callArgs_131[2] = ((long) iL[4]); + callArgs_131[1] = ((long) iL[12]); + callArgs_131[0] = ((long) iL[10]); + long[] callResult_131 = ciRefInstance_131.getMachine().call(ciFuncId_131, callArgs_131); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_131[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 25860; + { + _hs[0] = 30029; + break _hb; + } + } + int ciTableIdx_132 = (int) (memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 244)); + int ciFuncId_132 = instance.table(0).requiredRef(ciTableIdx_132); + com.dylibso.chicory.runtime.Instance ciRefInstance_132 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_132), instance); + if (!ciRefInstance_132.type(ciRefInstance_132.functionType(ciFuncId_132)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_132 = new long[3]; + callArgs_132[2] = ((long) iL[13]); + callArgs_132[1] = ((long) iL[12]); + callArgs_132[0] = ((long) iL[10]); + long[] callResult_132 = ciRefInstance_132.getMachine().call(ciFuncId_132, callArgs_132); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_132[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 25823; + { + _hs[0] = 30029; + break _hb; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 352, (int) 0); + label_192: { + label_193: { + if (((int) memory.read((int) memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) < 0 ? memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) : memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) + 15) & 0xFF) != 0) { + break label_193; + } + long[] callArgs_133 = new long[3]; + callArgs_133[2] = ((long) 18754); + callArgs_133[1] = ((long) (iL[3] + 336)); + callArgs_133[0] = ((long) iL[0]); + long[] callResult_133 = instance.getMachine().call(811, callArgs_133); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_133[0])) != 0) { + break _hb; + } + label_194: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 336) & 0xFF)) != 0) { + break label_194; + } + long[] callArgs_134 = new long[3]; + callArgs_134[2] = ((long) 0); + callArgs_134[1] = ((long) 28702); + callArgs_134[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_134); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + iL[4] = 0; + break label_192; + } + long[] callArgs_135 = new long[3]; + callArgs_135[2] = ((long) 2379); + callArgs_135[1] = ((long) (iL[3] + 352)); + callArgs_135[0] = ((long) iL[0]); + long[] callResult_135 = instance.getMachine().call(828, callArgs_135); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_135[0])) != 0) { + break _hb; + } + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + } + label_195: { + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_136 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 444)); + int ciFuncId_136 = instance.table(0).requiredRef(ciTableIdx_136); + com.dylibso.chicory.runtime.Instance ciRefInstance_136 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_136), instance); + if (!ciRefInstance_136.type(ciRefInstance_136.functionType(ciFuncId_136)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_136 = new long[2]; + callArgs_136[1] = ((long) iL[4]); + callArgs_136[0] = ((long) iL[12]); + long[] callResult_136 = ciRefInstance_136.getMachine().call(ciFuncId_136, callArgs_136); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_136[0])) != 0) { + break label_195; + } + long[] callArgs_137 = new long[3]; + callArgs_137[2] = ((long) 0); + callArgs_137[1] = ((long) 22333); + callArgs_137[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_137); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_138 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 232)); + int ciFuncId_138 = instance.table(0).requiredRef(ciTableIdx_138); + com.dylibso.chicory.runtime.Instance ciRefInstance_138 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_138), instance); + if (!ciRefInstance_138.type(ciRefInstance_138.functionType(ciFuncId_138)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_138 = new long[2]; + callArgs_138[1] = ((long) iL[4]); + callArgs_138[0] = ((long) iL[12]); + long[] callResult_138 = ciRefInstance_138.getMachine().call(ciFuncId_138, callArgs_138); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_138[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + long[] callArgs_139 = new long[3]; + callArgs_139[2] = ((long) 0); + callArgs_139[1] = ((long) 25792); + callArgs_139[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_139); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 352, (int) 0); + label_196: { + label_197: { + if (((int) memory.read((int) memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) < 0 ? memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) : memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0) + 15) & 0xFF) != 0) { + break label_197; + } + long[] callArgs_140 = new long[3]; + callArgs_140[2] = ((long) 18682); + callArgs_140[1] = ((long) (iL[3] + 336)); + callArgs_140[0] = ((long) iL[0]); + long[] callResult_140 = instance.getMachine().call(811, callArgs_140); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_140[0])) != 0) { + break _hb; + } + label_198: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 336) & 0xFF)) != 0) { + break label_198; + } + long[] callArgs_141 = new long[3]; + callArgs_141[2] = ((long) 0); + callArgs_141[1] = ((long) 28582); + callArgs_141[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_141); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + iL[4] = 0; + break label_196; + } + long[] callArgs_142 = new long[3]; + callArgs_142[2] = ((long) 2310); + callArgs_142[1] = ((long) (iL[3] + 352)); + callArgs_142[0] = ((long) iL[0]); + long[] callResult_142 = instance.getMachine().call(828, callArgs_142); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_142[0])) != 0) { + break _hb; + } + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + } + iL[12] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_143 = (int) (memory.readInt((int) memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) < 0 ? memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) : memory.readInt((int) iL[12] < 0 ? iL[12] : iL[12] + 0) + 436)); + int ciFuncId_143 = instance.table(0).requiredRef(ciTableIdx_143); + com.dylibso.chicory.runtime.Instance ciRefInstance_143 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_143), instance); + if (!ciRefInstance_143.type(ciRefInstance_143.functionType(ciFuncId_143)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_143 = new long[2]; + callArgs_143[1] = ((long) iL[4]); + callArgs_143[0] = ((long) iL[12]); + long[] callResult_143 = ciRefInstance_143.getMachine().call(ciFuncId_143, callArgs_143); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_143[0])) != 0) { + { + _hs[0] = 5; + break _hb; + } + } + long[] callArgs_144 = new long[3]; + callArgs_144[2] = ((long) 0); + callArgs_144[1] = ((long) 20617); + callArgs_144[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_144); + } while (false); + return _hs[0]; + } + + private static int func_801__h16(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_366: { + int _d21 = func_801__h21(iL, lL, memory, instance); + if (_d21 >= 10000) { + _hs[0] = (_d21 - 10000); + break _hb; + } + } + label_395: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_423 = new long[3]; + callArgs_423[2] = ((long) (iL[4] + 3168)); + callArgs_423[1] = ((long) (iL[13] + iL[14])); + callArgs_423[0] = ((long) (iL[13] + iL[3])); + long[] callResult_423 = instance.getMachine().call(177, callArgs_423); + iL[3] = ((int) callResult_423[0]); + if (iL[3] != 0) { + break label_395; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1712, (int) 6276); + long[] callArgs_424 = new long[3]; + callArgs_424[2] = ((long) (iL[4] + 1712)); + callArgs_424[1] = ((long) 11260); + callArgs_424[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_424); + { + _hs[0] = 1; + break _hb; + } + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_396: { + iL[18] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[18], iL[3]) != 0) { + break label_396; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1736, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1732, (int) iL[18]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1728, (int) 6276); + long[] callArgs_425 = new long[3]; + callArgs_425[2] = ((long) (iL[4] + 1728)); + callArgs_425[1] = ((long) 12552); + callArgs_425[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_425); + { + _hs[0] = 1; + break _hb; + } + } + label_397: { + label_398: { + label_399: { + label_400: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2988); + iL[3] = ((memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2992) - iL[13]) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[18], iL[3]) != 0) { + break label_400; + } + long[] callArgs_426 = new long[2]; + callArgs_426[1] = ((long) (iL[18] - iL[3])); + callArgs_426[0] = ((long) iL[9]); + instance.getMachine().call(248, callArgs_426); + break label_399; + } + label_401: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[18], iL[3]) != 0) { + break label_401; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2992, (int) (iL[13] + (iL[18] << 3))); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[18]) != 0) { + break label_398; + } + } + iL[3] = 0; + iL[13] = iL[18]; + label_402: while (true) { + long[] callArgs_427 = new long[3]; + callArgs_427[2] = ((long) 15795); + callArgs_427[1] = ((long) (iL[4] + 3168)); + callArgs_427[0] = ((long) (iL[4] + 2936)); + long[] callResult_427 = instance.getMachine().call(805, callArgs_427); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_427[0])) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036); + label_403: { + label_404: { + label_405: { + label_406: { + label_407: { + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[15] = (int) lL[0]; + switch((iL[15] + 23)) { + case 0: + { + break label_407; + } + case 1: + { + { + _hs[0] = 3; + break _hb; + } + } + case 2: + { + break label_406; + } + case 3: + { + { + _hs[0] = 3; + break _hb; + } + } + case 4: + { + { + _hs[0] = 3; + break _hb; + } + } + case 5: + { + { + _hs[0] = 3; + break _hb; + } + } + case 6: + { + break label_404; + } + case 7: + { + break label_404; + } + case 8: + { + { + _hs[0] = 3; + break _hb; + } + } + case 9: + { + { + _hs[0] = 3; + break _hb; + } + } + case 10: + { + { + _hs[0] = 3; + break _hb; + } + } + case 11: + { + { + _hs[0] = 3; + break _hb; + } + } + case 12: + { + { + _hs[0] = 3; + break _hb; + } + } + case 13: + { + { + _hs[0] = 3; + break _hb; + } + } + case 14: + { + { + _hs[0] = 3; + break _hb; + } + } + case 15: + { + { + _hs[0] = 3; + break _hb; + } + } + case 16: + { + { + _hs[0] = 3; + break _hb; + } + } + case 17: + { + { + _hs[0] = 3; + break _hb; + } + } + case 18: + { + break label_405; + } + case 19: + { + break label_403; + } + case 20: + { + break label_403; + } + case 21: + { + break label_403; + } + case 22: + { + break label_403; + } + default: + { + { + _hs[0] = 3; + break _hb; + } + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[14] < 0 ? iL[14] : iL[14] + 0) & 0xFF)) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + break label_403; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[14] < 0 ? iL[14] : iL[14] + 6) & 0xFF)) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + break label_403; + } + if (((int) memory.read((int) iL[14] < 0 ? iL[14] : iL[14] + 4) & 0xFF) != 0) { + break label_403; + } + { + _hs[0] = 3; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[14] < 0 ? iL[14] : iL[14] + 10) & 0xFF)) != 0) { + { + _hs[0] = 3; + break _hb; + } + } + } + memory.writeLong((int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2988) + iL[3]) < 0 ? (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2988) + iL[3]) : (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2988) + iL[3]) + 0, (long) lL[0]); + iL[3] = (iL[3] + 8); + iL[13] = (iL[13] + -1); + if (iL[13] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_402; + } + break; + } + iL[3] = (iL[19] != 0 ? 0 : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2976)); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2988); + break label_397; + } + iL[13] = 0; + iL[3] = (iL[19] != 0 ? 0 : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2976)); + } + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_428 = (int) (memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 44)); + int ciFuncId_428 = instance.table(0).requiredRef(ciTableIdx_428); + com.dylibso.chicory.runtime.Instance ciRefInstance_428 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_428), instance); + if (!ciRefInstance_428.type(ciRefInstance_428.functionType(ciFuncId_428)).typesMatch(instance.type(7))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_428 = new long[6]; + callArgs_428[5] = ((long) iL[13]); + callArgs_428[4] = ((long) iL[18]); + callArgs_428[3] = ((long) iL[3]); + callArgs_428[2] = ((long) iL[16]); + callArgs_428[1] = ((long) iL[17]); + callArgs_428[0] = ((long) iL[14]); + long[] callResult_428 = ciRefInstance_428.getMachine().call(ciFuncId_428, callArgs_428); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_428[0])) != 0) { + break _hb; + } + long[] callArgs_429 = new long[3]; + callArgs_429[2] = ((long) 0); + callArgs_429[1] = ((long) 25307); + callArgs_429[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_429); + { + _hs[0] = 1; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h13(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_86: { + label_87: { + label_88: { + label_89: { + label_90: { + label_91: { + int _d2 = func_804__h2(iL, lL, memory, instance); + if (_d2 == 1) + break label_89; + if (_d2 == 2) + break _hb; + if (_d2 == 3) + break label_86; + if (_d2 == 4) { + _hs[0] = 1; + break _hb; + } + if (_d2 == 5) + break label_87; + if (_d2 == 6) + break label_88; + if (_d2 == 7) + break label_90; + if (_d2 == 8) { + _hs[0] = 2; + break _hb; + } + if (_d2 == 9) { + _hs[0] = 3; + break _hb; + } + if (_d2 == 10) { + _hs[0] = 20000; + break _hb; + } + if (_d2 == 11) { + _hs[0] = 20001; + break _hb; + } + if (_d2 == 12) { + _hs[0] = 20002; + break _hb; + } + if (_d2 == 13) { + _hs[0] = 20003; + break _hb; + } + if (_d2 == 14) { + _hs[0] = 10001; + break _hb; + } + if (_d2 == 15) { + _hs[0] = 20004; + break _hb; + } + if (_d2 == 16) { + _hs[0] = 20005; + break _hb; + } + if (_d2 == 17) { + _hs[0] = 20006; + break _hb; + } + if (_d2 == 18) { + _hs[0] = 20007; + break _hb; + } + if (_d2 == 19) { + _hs[0] = 20008; + break _hb; + } + if (_d2 == 20) { + _hs[0] = 4; + break _hb; + } + if (_d2 == 21) { + _hs[0] = 10000; + break _hb; + } + if (_d2 == 22) { + _hs[0] = 10002; + break _hb; + } + if (_d2 == 23) { + _hs[0] = 10003; + break _hb; + } + if (_d2 == 24) { + _hs[0] = 10004; + break _hb; + } + if (_d2 == 25) { + _hs[0] = 10005; + break _hb; + } + if (_d2 == 26) { + _hs[0] = 10006; + break _hb; + } + if (_d2 >= 10000) { + _hs[0] = ((((_d2 - 10000)) + 10000) + 10000) + 10000; + break _hb; + } + } + long[] callArgs_191 = new long[2]; + callArgs_191[1] = ((long) (iL[3] + 448)); + callArgs_191[0] = ((long) (iL[3] + 456)); + instance.getMachine().call(820, callArgs_191); + iL[11] = 1; + long[] callArgs_192 = new long[3]; + callArgs_192[2] = ((long) 16157); + callArgs_192[1] = ((long) (iL[3] + 352)); + callArgs_192[0] = ((long) iL[0]); + long[] callResult_192 = instance.getMachine().call(805, callArgs_192); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_192[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 328, (long) lL[0]); + iL[4] = memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 216, (long) lL[0]); + label_214: { + long[] callArgs_193 = new long[2]; + callArgs_193[1] = ((long) (iL[3] + 216)); + callArgs_193[0] = ((long) iL[4]); + long[] callResult_193 = instance.getMachine().call(821, callArgs_193); + if (((int) callResult_193[0]) != 0) { + break label_214; + } + iL[4] = 16196; + { + _hs[0] = 30034; + break _hb; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 320, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 528); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 208, (long) lL[0]); + label_215: { + int ciTableIdx_194 = (int) (iL[12]); + int ciFuncId_194 = instance.table(0).requiredRef(ciTableIdx_194); + com.dylibso.chicory.runtime.Instance ciRefInstance_194 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_194), instance); + if (!ciRefInstance_194.type(ciRefInstance_194.functionType(ciFuncId_194)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_194 = new long[2]; + callArgs_194[1] = ((long) (iL[3] + 208)); + callArgs_194[0] = ((long) iL[4]); + long[] callResult_194 = ciRefInstance_194.getMachine().call(ciFuncId_194, callArgs_194); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_194[0])) != 0) { + break label_215; + } + iL[4] = 20433; + { + _hs[0] = 30034; + break _hb; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 312, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 272); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 200, (long) lL[0]); + int ciTableIdx_195 = (int) (iL[12]); + int ciFuncId_195 = instance.table(0).requiredRef(ciTableIdx_195); + com.dylibso.chicory.runtime.Instance ciRefInstance_195 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_195), instance); + if (!ciRefInstance_195.type(ciRefInstance_195.functionType(ciFuncId_195)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_195 = new long[2]; + callArgs_195[1] = ((long) (iL[3] + 200)); + callArgs_195[0] = ((long) iL[4]); + long[] callResult_195 = ciRefInstance_195.getMachine().call(ciFuncId_195, callArgs_195); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_195[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 25041; + { + _hs[0] = 30034; + break _hb; + } + } + long[] callArgs_196 = new long[2]; + callArgs_196[1] = ((long) (iL[3] + 448)); + callArgs_196[0] = ((long) (iL[3] + 456)); + instance.getMachine().call(820, callArgs_196); + iL[11] = 1; + long[] callArgs_197 = new long[3]; + callArgs_197[2] = ((long) 16250); + callArgs_197[1] = ((long) (iL[3] + 352)); + callArgs_197[0] = ((long) iL[0]); + long[] callResult_197 = instance.getMachine().call(805, callArgs_197); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_197[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 304, (long) lL[0]); + iL[4] = memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 232, (long) lL[0]); + label_216: { + long[] callArgs_198 = new long[2]; + callArgs_198[1] = ((long) (iL[3] + 232)); + callArgs_198[0] = ((long) iL[4]); + long[] callResult_198 = instance.getMachine().call(821, callArgs_198); + if (((int) callResult_198[0]) != 0) { + break label_216; + } + long[] callArgs_199 = new long[3]; + callArgs_199[2] = ((long) 0); + callArgs_199[1] = ((long) 16196); + callArgs_199[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_199); + { + _hs[0] = 30007; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_200 = new long[3]; + callArgs_200[2] = ((long) 6531); + callArgs_200[1] = ((long) (iL[3] + 336)); + callArgs_200[0] = ((long) iL[0]); + long[] callResult_200 = instance.getMachine().call(813, callArgs_200); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_200[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + iL[14] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + long[] callArgs_201 = new long[2]; + callArgs_201[1] = ((long) iL[14]); + callArgs_201[0] = ((long) iL[7]); + instance.getMachine().call(830, callArgs_201); + label_217: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[14]) != 0) { + break label_217; + } + iL[4] = 0; + label_218: while (true) { + long[] callArgs_202 = new long[3]; + callArgs_202[2] = ((long) 11591); + callArgs_202[1] = ((long) (iL[3] + 303)); + callArgs_202[0] = ((long) iL[0]); + long[] callResult_202 = instance.getMachine().call(811, callArgs_202); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_202[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_219: { + iL[12] = ((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 303) & 0xFF); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[12], 4) != 0) { + break label_219; + } + long[] callArgs_203 = new long[3]; + callArgs_203[2] = ((long) 0); + callArgs_203[1] = ((long) 11576); + callArgs_203[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_203); + { + _hs[0] = 30007; + break _hb; + } + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 348, (int) -1); + label_220: { + if ((iL[12] & 2) != 0) { + break label_220; + } + long[] callArgs_204 = new long[3]; + callArgs_204[2] = ((long) 14704); + callArgs_204[1] = ((long) (iL[3] + 348)); + callArgs_204[0] = ((long) iL[0]); + long[] callResult_204 = instance.getMachine().call(814, callArgs_204); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_204[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + } + long[] callArgs_205 = new long[3]; + callArgs_205[2] = ((long) 14148); + callArgs_205[1] = ((long) (iL[3] + 296)); + callArgs_205[0] = ((long) iL[0]); + long[] callResult_205 = instance.getMachine().call(814, callArgs_205); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_205[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + iL[10] = (memory.readInt((int) iL[7] < 0 ? iL[7] : iL[7] + 0) + iL[4]); + memory.writeI32((int) iL[10] < 0 ? iL[10] : iL[10] + 0, (int) iL[12]); + memory.writeI32((int) (iL[10] + 8) < 0 ? (iL[10] + 8) : (iL[10] + 8) + 0, (int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 296)); + memory.writeI32((int) (iL[10] + 4) < 0 ? (iL[10] + 4) : (iL[10] + 4) + 0, (int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 348)); + iL[4] = (iL[4] + 12); + iL[14] = (iL[14] + -1); + if (iL[14] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_218; + } + break; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 288, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 532); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 224, (long) lL[0]); + int ciTableIdx_206 = (int) (iL[12]); + int ciFuncId_206 = instance.table(0).requiredRef(ciTableIdx_206); + com.dylibso.chicory.runtime.Instance ciRefInstance_206 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_206), instance); + if (!ciRefInstance_206.type(ciRefInstance_206.functionType(ciFuncId_206)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_206 = new long[3]; + callArgs_206[2] = ((long) iL[7]); + callArgs_206[1] = ((long) (iL[3] + 224)); + callArgs_206[0] = ((long) iL[4]); + long[] callResult_206 = ciRefInstance_206.getMachine().call(ciFuncId_206, callArgs_206); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_206[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + long[] callArgs_207 = new long[3]; + callArgs_207[2] = ((long) 0); + callArgs_207[1] = ((long) 22653); + callArgs_207[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_207); + { + _hs[0] = 30007; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_208 = new long[3]; + callArgs_208[2] = ((long) 1782); + callArgs_208[1] = ((long) (iL[3] + 352)); + callArgs_208[0] = ((long) iL[0]); + long[] callResult_208 = instance.getMachine().call(814, callArgs_208); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_208[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_221: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_209 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 340)); + int ciFuncId_209 = instance.table(0).requiredRef(ciTableIdx_209); + com.dylibso.chicory.runtime.Instance ciRefInstance_209 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_209), instance); + if (!ciRefInstance_209.type(ciRefInstance_209.functionType(ciFuncId_209)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_209 = new long[2]; + callArgs_209[1] = ((long) iL[12]); + callArgs_209[0] = ((long) iL[4]); + long[] callResult_209 = ciRefInstance_209.getMachine().call(ciFuncId_209, callArgs_209); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_209[0])) != 0) { + break label_221; + } + iL[4] = 22153; + { + _hs[0] = 30035; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_210 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_210 = instance.table(0).requiredRef(ciTableIdx_210); + com.dylibso.chicory.runtime.Instance ciRefInstance_210 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_210), instance); + if (!ciRefInstance_210.type(ciRefInstance_210.functionType(ciFuncId_210)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_210 = new long[2]; + callArgs_210[1] = ((long) iL[12]); + callArgs_210[0] = ((long) iL[4]); + long[] callResult_210 = ciRefInstance_210.getMachine().call(ciFuncId_210, callArgs_210); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_210[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 30035; + break _hb; + } + } + label_222: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_211 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 344)); + int ciFuncId_211 = instance.table(0).requiredRef(ciTableIdx_211); + com.dylibso.chicory.runtime.Instance ciRefInstance_211 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_211), instance); + if (!ciRefInstance_211.type(ciRefInstance_211.functionType(ciFuncId_211)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_211 = new long[1]; + callArgs_211[0] = ((long) iL[4]); + long[] callResult_211 = ciRefInstance_211.getMachine().call(ciFuncId_211, callArgs_211); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_211[0])) != 0) { + break label_222; + } + long[] callArgs_212 = new long[3]; + callArgs_212[2] = ((long) 0); + callArgs_212[1] = ((long) 22094); + callArgs_212[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_212); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_213 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_213 = instance.table(0).requiredRef(ciTableIdx_213); + com.dylibso.chicory.runtime.Instance ciRefInstance_213 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_213), instance); + if (!ciRefInstance_213.type(ciRefInstance_213.functionType(ciFuncId_213)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_213 = new long[1]; + callArgs_213[0] = ((long) iL[4]); + long[] callResult_213 = ciRefInstance_213.getMachine().call(ciFuncId_213, callArgs_213); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_213[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + long[] callArgs_214 = new long[3]; + callArgs_214[2] = ((long) 0); + callArgs_214[1] = ((long) 25128); + callArgs_214[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_214); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + label_223: { + label_224: { + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 476); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_224; + } + iL[4] = ((iL[4] + memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 472)) + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(6, memory.readInt((int) (memory.readInt((int) (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) < 0 ? (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) : (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) + 0) + ((iL[4] & 1023) << 2)) < 0 ? (memory.readInt((int) (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) < 0 ? (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) : (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) + 0) + ((iL[4] & 1023) << 2)) : (memory.readInt((int) (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) < 0 ? (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) : (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) + 0) + ((iL[4] & 1023) << 2)) + 0)) != 0) { + break label_223; + } + } + long[] callArgs_215 = new long[3]; + callArgs_215[2] = ((long) 0); + callArgs_215[1] = ((long) 13878); + callArgs_215[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_215); + iL[11] = 1; + { + _hs[0] = 30007; + break _hb; + } + } + long[] callArgs_216 = new long[1]; + callArgs_216[0] = ((long) (iL[3] + 456)); + instance.getMachine().call(831, callArgs_216); + iL[11] = 1; + long[] callArgs_217 = new long[3]; + callArgs_217[2] = ((long) 14219); + callArgs_217[1] = ((long) (iL[3] + 352)); + callArgs_217[0] = ((long) iL[0]); + long[] callResult_217 = instance.getMachine().call(814, callArgs_217); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_217[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_225: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_218 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 356)); + int ciFuncId_218 = instance.table(0).requiredRef(ciTableIdx_218); + com.dylibso.chicory.runtime.Instance ciRefInstance_218 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_218), instance); + if (!ciRefInstance_218.type(ciRefInstance_218.functionType(ciFuncId_218)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_218 = new long[2]; + callArgs_218[1] = ((long) iL[12]); + callArgs_218[0] = ((long) iL[4]); + long[] callResult_218 = ciRefInstance_218.getMachine().call(ciFuncId_218, callArgs_218); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_218[0])) != 0) { + break label_225; + } + iL[4] = 22398; + { + _hs[0] = 30036; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_219 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_219 = instance.table(0).requiredRef(ciTableIdx_219); + com.dylibso.chicory.runtime.Instance ciRefInstance_219 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_219), instance); + if (!ciRefInstance_219.type(ciRefInstance_219.functionType(ciFuncId_219)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_219 = new long[2]; + callArgs_219[1] = ((long) iL[12]); + callArgs_219[0] = ((long) iL[4]); + long[] callResult_219 = ciRefInstance_219.getMachine().call(ciFuncId_219, callArgs_219); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_219[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 30036; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_220 = new long[3]; + callArgs_220[2] = ((long) 14148); + callArgs_220[1] = ((long) (iL[3] + 352)); + callArgs_220[0] = ((long) iL[0]); + long[] callResult_220 = instance.getMachine().call(814, callArgs_220); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_220[0])) != 0) { + { + _hs[0] = 30007; + break _hb; + } + } + label_226: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_221 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 496)); + int ciFuncId_221 = instance.table(0).requiredRef(ciTableIdx_221); + com.dylibso.chicory.runtime.Instance ciRefInstance_221 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_221), instance); + if (!ciRefInstance_221.type(ciRefInstance_221.functionType(ciFuncId_221)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_221 = new long[2]; + callArgs_221[1] = ((long) iL[12]); + callArgs_221[0] = ((long) iL[4]); + long[] callResult_221 = ciRefInstance_221.getMachine().call(ciFuncId_221, callArgs_221); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_221[0])) != 0) { + break label_226; + } + iL[4] = 20559; + { + _hs[0] = 30037; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_222 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_222 = instance.table(0).requiredRef(ciTableIdx_222); + com.dylibso.chicory.runtime.Instance ciRefInstance_222 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_222), instance); + if (!ciRefInstance_222.type(ciRefInstance_222.functionType(ciFuncId_222)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_222 = new long[2]; + callArgs_222[1] = ((long) iL[12]); + callArgs_222[0] = ((long) iL[4]); + long[] callResult_222 = ciRefInstance_222.getMachine().call(ciFuncId_222, callArgs_222); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_222[0])) != 0) { + { + _hs[0] = 30008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 30037; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h17(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[19] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[19] < 0 ? iL[19] : iL[19] + 24) & 0xFF)) != 0) { + break _hb; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(4, iL[17]) != 0) { + break _hb; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1701667182, memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0)) != 0) { + { + _hs[0] = 30004; + break _hb; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_32 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 668)); + int ciFuncId_32 = instance.table(0).requiredRef(ciTableIdx_32); + com.dylibso.chicory.runtime.Instance ciRefInstance_32 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_32), instance); + if (!ciRefInstance_32.type(ciRefInstance_32.functionType(ciFuncId_32)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) iL[0]); + callArgs_32[0] = ((long) iL[3]); + long[] callResult_32 = ciRefInstance_32.getMachine().call(ciFuncId_32, callArgs_32); + if (((int) callResult_32[0]) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + label_68: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[3], iL[0]) != 0) { + break label_68; + } + iL[16] = 0; + iL[13] = 0; + label_69: while (true) { + label_70: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_33 = new long[3]; + callArgs_33[2] = ((long) (iL[4] + 3216)); + callArgs_33[1] = ((long) (iL[15] + iL[0])); + callArgs_33[0] = ((long) (iL[15] + iL[3])); + long[] callResult_33 = instance.getMachine().call(177, callArgs_33); + iL[3] = ((int) callResult_33[0]); + if (iL[3] != 0) { + break label_70; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 128, (int) 16298); + long[] callArgs_34 = new long[3]; + callArgs_34[2] = ((long) (iL[4] + 128)); + callArgs_34[1] = ((long) 11260); + callArgs_34[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_34); + { + _hs[0] = 40002; + break _hb; + } + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + iL[20] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3216); + label_71: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[16]) != 0) { + break label_71; + } + label_72: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[13], iL[20]) != 0) { + break label_72; + } + long[] callArgs_35 = new long[3]; + callArgs_35[2] = ((long) 0); + callArgs_35[1] = ((long) 12391); + callArgs_35[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_35); + { + _hs[0] = 40002; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[20], iL[13]) != 0) { + break label_71; + } + long[] callArgs_36 = new long[3]; + callArgs_36[2] = ((long) 0); + callArgs_36[1] = ((long) 12366); + callArgs_36[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_36); + { + _hs[0] = 40002; + break _hb; + } + } + label_73: { + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_37 = new long[3]; + callArgs_37[2] = ((long) (iL[4] + 3168)); + callArgs_37[1] = ((long) (iL[0] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_37[0] = ((long) (iL[0] + iL[3])); + long[] callResult_37 = instance.getMachine().call(177, callArgs_37); + iL[3] = ((int) callResult_37[0]); + if (iL[3] != 0) { + break label_73; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 144, (int) 14996); + long[] callArgs_38 = new long[3]; + callArgs_38[2] = ((long) (iL[4] + 144)); + callArgs_38[1] = ((long) 11260); + callArgs_38[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_38); + { + _hs[0] = 40002; + break _hb; + } + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_74: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[3] = (iL[13] + iL[3]); + iL[0] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[3], iL[0]) != 0) { + break label_74; + } + long[] callArgs_39 = new long[3]; + callArgs_39[2] = ((long) 0); + callArgs_39[1] = ((long) 17707); + callArgs_39[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_39); + { + _hs[0] = 40002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[3]); + label_75: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3216); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S(iL[15], 11) != 0) { + break label_75; + } + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_40 = (int) (memory.readInt((int) memory.readInt((int) iL[17] < 0 ? iL[17] : iL[17] + 0) < 0 ? memory.readInt((int) iL[17] < 0 ? iL[17] : iL[17] + 0) : memory.readInt((int) iL[17] < 0 ? iL[17] : iL[17] + 0) + 708)); + int ciFuncId_40 = instance.table(0).requiredRef(ciTableIdx_40); + com.dylibso.chicory.runtime.Instance ciRefInstance_40 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_40), instance); + if (!ciRefInstance_40.type(ciRefInstance_40.functionType(ciFuncId_40)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_40 = new long[4]; + callArgs_40[3] = ((long) iL[13]); + callArgs_40[2] = ((long) iL[15]); + callArgs_40[1] = ((long) iL[16]); + callArgs_40[0] = ((long) iL[17]); + long[] callResult_40 = ciRefInstance_40.getMachine().call(ciFuncId_40, callArgs_40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_40[0])) != 0) { + break label_75; + } + long[] callArgs_41 = new long[3]; + callArgs_41[2] = ((long) 0); + callArgs_41[1] = ((long) 23085); + callArgs_41[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_41); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + label_76: { + label_77: { + label_78: { + int _d22 = func_801__h22(iL, lL, memory, instance); + if (_d22 == 1) + break label_77; + if (_d22 == 2) + break label_76; + if (_d22 >= 10000) { + _hs[0] = (_d22 - 10000); + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_77; + } + label_107: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_82 = new long[3]; + callArgs_82[2] = ((long) (iL[4] + 3168)); + callArgs_82[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_82[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_82 = instance.getMachine().call(177, callArgs_82); + iL[13] = ((int) callResult_82[0]); + if (iL[13] != 0) { + break label_107; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 432, (int) 6595); + long[] callArgs_83 = new long[3]; + callArgs_83[2] = ((long) (iL[4] + 432)); + callArgs_83[1] = ((long) 11260); + callArgs_83[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_83); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + iL[17] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[17]); + label_108: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[17] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[17]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[13], iL[17]) != 0) { + break label_108; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 456, (int) iL[17]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 452, (int) iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 448, (int) 6595); + long[] callArgs_84 = new long[3]; + callArgs_84[2] = ((long) (iL[4] + 448)); + callArgs_84[1] = ((long) 12552); + callArgs_84[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_84); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_85 = (int) (memory.readInt((int) memory.readInt((int) iL[17] < 0 ? iL[17] : iL[17] + 0) < 0 ? memory.readInt((int) iL[17] < 0 ? iL[17] : iL[17] + 0) : memory.readInt((int) iL[17] < 0 ? iL[17] : iL[17] + 0) + 712)); + int ciFuncId_85 = instance.table(0).requiredRef(ciTableIdx_85); + com.dylibso.chicory.runtime.Instance ciRefInstance_85 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_85), instance); + if (!ciRefInstance_85.type(ciRefInstance_85.functionType(ciFuncId_85)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_85 = new long[2]; + callArgs_85[1] = ((long) iL[13]); + callArgs_85[0] = ((long) iL[17]); + long[] callResult_85 = ciRefInstance_85.getMachine().call(ciFuncId_85, callArgs_85); + if (((int) callResult_85[0]) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_77; + } + label_109: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + label_110: { + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_86 = new long[3]; + callArgs_86[2] = ((long) (iL[4] + 3224)); + callArgs_86[1] = ((long) (iL[17] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_86[0] = ((long) (iL[17] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_86 = instance.getMachine().call(177, callArgs_86); + iL[17] = ((int) callResult_86[0]); + if (iL[17] != 0) { + break label_110; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 464, (int) 2231); + long[] callArgs_87 = new long[3]; + callArgs_87[2] = ((long) (iL[4] + 464)); + callArgs_87[1] = ((long) 11260); + callArgs_87[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_87); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[17])); + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3224); + long[] callArgs_88 = new long[3]; + callArgs_88[2] = ((long) 16984); + callArgs_88[1] = ((long) (iL[4] + 3168)); + callArgs_88[0] = ((long) (iL[4] + 2936)); + long[] callResult_88 = instance.getMachine().call(803, callArgs_88); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_88[0])) != 0) { + { + _hs[0] = 40003; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3232, (long) lL[0]); + iL[18] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[19] = memory.readInt((int) memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0) < 0 ? memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0) : memory.readInt((int) iL[18] < 0 ? iL[18] : iL[18] + 0) + 716); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 472, (long) lL[0]); + label_111: { + int ciTableIdx_89 = (int) (iL[19]); + int ciFuncId_89 = instance.table(0).requiredRef(ciTableIdx_89); + com.dylibso.chicory.runtime.Instance ciRefInstance_89 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_89), instance); + if (!ciRefInstance_89.type(ciRefInstance_89.functionType(ciFuncId_89)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_89 = new long[4]; + callArgs_89[3] = ((long) (iL[4] + 472)); + callArgs_89[2] = ((long) iL[17]); + callArgs_89[1] = ((long) iL[15]); + callArgs_89[0] = ((long) iL[18]); + long[] callResult_89 = ciRefInstance_89.getMachine().call(ciFuncId_89, callArgs_89); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_89[0])) != 0) { + break label_111; + } + long[] callArgs_90 = new long[3]; + callArgs_90[2] = ((long) 0); + callArgs_90[1] = ((long) 18931); + callArgs_90[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_90); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + iL[13] = (iL[13] + -1); + if (iL[13] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_109; + } + break; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + } + label_112: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[3], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948)) != 0) { + break label_112; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 160, (int) iL[3]); + long[] callArgs_91 = new long[3]; + callArgs_91[2] = ((long) (iL[4] + 160)); + callArgs_91[1] = ((long) 29336); + callArgs_91[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_91); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + iL[16] = (iL[16] + 1); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + iL[13] = iL[20]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[3], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_69; + } + break; + } + } + label_113: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_92 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 720)); + int ciFuncId_92 = instance.table(0).requiredRef(ciTableIdx_92); + com.dylibso.chicory.runtime.Instance ciRefInstance_92 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_92), instance); + if (!ciRefInstance_92.type(ciRefInstance_92.functionType(ciFuncId_92)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_92 = new long[1]; + callArgs_92[0] = ((long) iL[3]); + long[] callResult_92 = ciRefInstance_92.getMachine().call(ciFuncId_92, callArgs_92); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_92[0])) != 0) { + break label_113; + } + long[] callArgs_93 = new long[3]; + callArgs_93[2] = ((long) 0); + callArgs_93[1] = ((long) 23657); + callArgs_93[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_93); + { + _hs[0] = 40002; + break _hb; + } + } + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 3044, (byte) (1)); + { + _hs[0] = 40004; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h14(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_132: { + label_133: { + label_134: { + label_135: { + int _d16 = func_804__h16(iL, lL, memory, instance); + if (_d16 == 1) + break label_134; + if (_d16 == 2) + break label_133; + if (_d16 == 3) + break label_132; + if (_d16 >= 10000) { + _hs[0] = (_d16 - 10000); + break _hb; + } + } + long[] callArgs_11 = new long[2]; + callArgs_11[1] = ((long) (iL[3] + 448)); + callArgs_11[0] = ((long) (iL[3] + 456)); + instance.getMachine().call(820, callArgs_11); + iL[11] = 1; + long[] callArgs_12 = new long[3]; + callArgs_12[2] = ((long) 16211); + callArgs_12[1] = ((long) (iL[3] + 352)); + callArgs_12[0] = ((long) iL[0]); + long[] callResult_12 = instance.getMachine().call(805, callArgs_12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_12[0])) != 0) { + { + _hs[0] = 40007; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 440, (long) lL[0]); + iL[4] = memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 40, (long) lL[0]); + label_138: { + long[] callArgs_13 = new long[2]; + callArgs_13[1] = ((long) (iL[3] + 40)); + callArgs_13[0] = ((long) iL[4]); + long[] callResult_13 = instance.getMachine().call(821, callArgs_13); + if (((int) callResult_13[0]) != 0) { + break label_138; + } + iL[4] = 16196; + { + _hs[0] = 40009; + break _hb; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 432, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 312); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 32, (long) lL[0]); + label_139: { + int ciTableIdx_14 = (int) (iL[12]); + int ciFuncId_14 = instance.table(0).requiredRef(ciTableIdx_14); + com.dylibso.chicory.runtime.Instance ciRefInstance_14 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_14), instance); + if (!ciRefInstance_14.type(ciRefInstance_14.functionType(ciFuncId_14)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_14 = new long[2]; + callArgs_14[1] = ((long) (iL[3] + 32)); + callArgs_14[0] = ((long) iL[4]); + long[] callResult_14 = ciRefInstance_14.getMachine().call(ciFuncId_14, callArgs_14); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_14[0])) != 0) { + break label_139; + } + iL[4] = 22125; + { + _hs[0] = 40009; + break _hb; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 424, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 272); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 24, (long) lL[0]); + int ciTableIdx_15 = (int) (iL[12]); + int ciFuncId_15 = instance.table(0).requiredRef(ciTableIdx_15); + com.dylibso.chicory.runtime.Instance ciRefInstance_15 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_15), instance); + if (!ciRefInstance_15.type(ciRefInstance_15.functionType(ciFuncId_15)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_15 = new long[2]; + callArgs_15[1] = ((long) (iL[3] + 24)); + callArgs_15[0] = ((long) iL[4]); + long[] callResult_15 = ciRefInstance_15.getMachine().call(ciFuncId_15, callArgs_15); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_15[0])) != 0) { + { + _hs[0] = 40008; + break _hb; + } + } + iL[4] = 25041; + { + _hs[0] = 40009; + break _hb; + } + } + long[] callArgs_16 = new long[2]; + callArgs_16[1] = ((long) (iL[3] + 448)); + callArgs_16[0] = ((long) (iL[3] + 456)); + instance.getMachine().call(820, callArgs_16); + iL[11] = 1; + long[] callArgs_17 = new long[3]; + callArgs_17[2] = ((long) 16176); + callArgs_17[1] = ((long) (iL[3] + 352)); + callArgs_17[0] = ((long) iL[0]); + long[] callResult_17 = instance.getMachine().call(805, callArgs_17); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_17[0])) != 0) { + { + _hs[0] = 40007; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 416, (long) lL[0]); + iL[4] = memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 64, (long) lL[0]); + label_140: { + long[] callArgs_18 = new long[2]; + callArgs_18[1] = ((long) (iL[3] + 64)); + callArgs_18[0] = ((long) iL[4]); + long[] callResult_18 = instance.getMachine().call(821, callArgs_18); + if (((int) callResult_18[0]) != 0) { + break label_140; + } + iL[4] = 16196; + { + _hs[0] = 40010; + break _hb; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 408, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 420); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 56, (long) lL[0]); + label_141: { + int ciTableIdx_19 = (int) (iL[12]); + int ciFuncId_19 = instance.table(0).requiredRef(ciTableIdx_19); + com.dylibso.chicory.runtime.Instance ciRefInstance_19 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_19), instance); + if (!ciRefInstance_19.type(ciRefInstance_19.functionType(ciFuncId_19)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_19 = new long[2]; + callArgs_19[1] = ((long) (iL[3] + 56)); + callArgs_19[0] = ((long) iL[4]); + long[] callResult_19 = ciRefInstance_19.getMachine().call(ciFuncId_19, callArgs_19); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_19[0])) != 0) { + break label_141; + } + iL[4] = 21667; + { + _hs[0] = 40010; + break _hb; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 400, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 272); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 48, (long) lL[0]); + int ciTableIdx_20 = (int) (iL[12]); + int ciFuncId_20 = instance.table(0).requiredRef(ciTableIdx_20); + com.dylibso.chicory.runtime.Instance ciRefInstance_20 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_20), instance); + if (!ciRefInstance_20.type(ciRefInstance_20.functionType(ciFuncId_20)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_20 = new long[2]; + callArgs_20[1] = ((long) (iL[3] + 48)); + callArgs_20[0] = ((long) iL[4]); + long[] callResult_20 = ciRefInstance_20.getMachine().call(ciFuncId_20, callArgs_20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_20[0])) != 0) { + { + _hs[0] = 40008; + break _hb; + } + } + iL[4] = 25041; + { + _hs[0] = 40010; + break _hb; + } + } + long[] callArgs_21 = new long[2]; + callArgs_21[1] = ((long) (iL[3] + 448)); + callArgs_21[0] = ((long) (iL[3] + 456)); + instance.getMachine().call(820, callArgs_21); + iL[11] = 1; + long[] callArgs_22 = new long[3]; + callArgs_22[2] = ((long) 16232); + callArgs_22[1] = ((long) (iL[3] + 352)); + callArgs_22[0] = ((long) iL[0]); + long[] callResult_22 = instance.getMachine().call(805, callArgs_22); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_22[0])) != 0) { + { + _hs[0] = 40007; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 392, (long) lL[0]); + iL[4] = memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 88, (long) lL[0]); + label_142: { + long[] callArgs_23 = new long[2]; + callArgs_23[1] = ((long) (iL[3] + 88)); + callArgs_23[0] = ((long) iL[4]); + long[] callResult_23 = instance.getMachine().call(821, callArgs_23); + if (((int) callResult_23[0]) != 0) { + break label_142; + } + iL[4] = 16196; + { + _hs[0] = 40011; + break _hb; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 384, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 400); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 80, (long) lL[0]); + label_143: { + int ciTableIdx_24 = (int) (iL[12]); + int ciFuncId_24 = instance.table(0).requiredRef(ciTableIdx_24); + com.dylibso.chicory.runtime.Instance ciRefInstance_24 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_24), instance); + if (!ciRefInstance_24.type(ciRefInstance_24.functionType(ciFuncId_24)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_24 = new long[2]; + callArgs_24[1] = ((long) (iL[3] + 80)); + callArgs_24[0] = ((long) iL[4]); + long[] callResult_24 = ciRefInstance_24.getMachine().call(ciFuncId_24, callArgs_24); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_24[0])) != 0) { + break label_143; + } + iL[4] = 22308; + { + _hs[0] = 40011; + break _hb; + } + } + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 376, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 272); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 72, (long) lL[0]); + int ciTableIdx_25 = (int) (iL[12]); + int ciFuncId_25 = instance.table(0).requiredRef(ciTableIdx_25); + com.dylibso.chicory.runtime.Instance ciRefInstance_25 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_25), instance); + if (!ciRefInstance_25.type(ciRefInstance_25.functionType(ciFuncId_25)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_25 = new long[2]; + callArgs_25[1] = ((long) (iL[3] + 72)); + callArgs_25[0] = ((long) iL[4]); + long[] callResult_25 = ciRefInstance_25.getMachine().call(ciFuncId_25, callArgs_25); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_25[0])) != 0) { + { + _hs[0] = 40008; + break _hb; + } + } + iL[4] = 25041; + { + _hs[0] = 40011; + break _hb; + } + } + label_144: { + label_145: { + iL[4] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 476); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[4]) != 0) { + break label_145; + } + iL[4] = ((iL[4] + memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 472)) + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(4, memory.readInt((int) (memory.readInt((int) (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) < 0 ? (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) : (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) + 0) + ((iL[4] & 1023) << 2)) < 0 ? (memory.readInt((int) (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) < 0 ? (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) : (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) + 0) + ((iL[4] & 1023) << 2)) : (memory.readInt((int) (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) < 0 ? (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) : (memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 460) + ((iL[4] >>> 8) & 16777212)) + 0) + ((iL[4] & 1023) << 2)) + 0)) != 0) { + break label_144; + } + } + long[] callArgs_26 = new long[3]; + callArgs_26[2] = ((long) 0); + callArgs_26[1] = ((long) 14004); + callArgs_26[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_26); + iL[11] = 1; + { + _hs[0] = 40007; + break _hb; + } + } + label_146: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_27 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 364)); + int ciFuncId_27 = instance.table(0).requiredRef(ciTableIdx_27); + com.dylibso.chicory.runtime.Instance ciRefInstance_27 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_27), instance); + if (!ciRefInstance_27.type(ciRefInstance_27.functionType(ciFuncId_27)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_27 = new long[1]; + callArgs_27[0] = ((long) iL[4]); + long[] callResult_27 = ciRefInstance_27.getMachine().call(ciFuncId_27, callArgs_27); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_27[0])) != 0) { + break label_146; + } + long[] callArgs_28 = new long[3]; + callArgs_28[2] = ((long) 0); + callArgs_28[1] = ((long) 22429); + callArgs_28[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_28); + iL[11] = 1; + { + _hs[0] = 40007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_29 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_29 = instance.table(0).requiredRef(ciTableIdx_29); + com.dylibso.chicory.runtime.Instance ciRefInstance_29 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_29), instance); + if (!ciRefInstance_29.type(ciRefInstance_29.functionType(ciFuncId_29)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_29 = new long[1]; + callArgs_29[0] = ((long) iL[4]); + long[] callResult_29 = ciRefInstance_29.getMachine().call(ciFuncId_29, callArgs_29); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_29[0])) != 0) { + { + _hs[0] = 40008; + break _hb; + } + } + long[] callArgs_30 = new long[3]; + callArgs_30[2] = ((long) 0); + callArgs_30[1] = ((long) 25128); + callArgs_30[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_30); + iL[11] = 1; + { + _hs[0] = 40007; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_1176__h7(int[] iL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_60: { + label_61: { + label_62: { + label_63: { + long[] callArgs_1 = new long[2]; + callArgs_1[1] = ((long) 0); + callArgs_1[0] = ((long) iL[0]); + long[] callResult_1 = instance.getMachine().call(1154, callArgs_1); + switch((((int) callResult_1[0]) + -60)) { + case 0: + { + { + _hs[0] = 40001; + break _hb; + } + } + case 1: + { + { + _hs[0] = 40002; + break _hb; + } + } + case 2: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 3: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 4: + { + { + _hs[0] = 40005; + break _hb; + } + } + case 5: + { + { + _hs[0] = 40006; + break _hb; + } + } + case 6: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 7: + { + { + _hs[0] = 20001; + break _hb; + } + } + case 8: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 9: + { + break _hb; + } + case 10: + { + { + _hs[0] = 1; + break _hb; + } + } + case 11: + { + { + _hs[0] = 2; + break _hb; + } + } + case 12: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 13: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 14: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 15: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 16: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 17: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 18: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 19: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 20: + { + { + _hs[0] = 20002; + break _hb; + } + } + case 21: + { + { + _hs[0] = 20003; + break _hb; + } + } + case 22: + { + { + _hs[0] = 20004; + break _hb; + } + } + case 23: + { + { + _hs[0] = 30001; + break _hb; + } + } + case 24: + { + break label_61; + } + case 25: + { + { + _hs[0] = 30002; + break _hb; + } + } + case 26: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 27: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 28: + { + { + _hs[0] = 20005; + break _hb; + } + } + case 29: + { + { + _hs[0] = 20006; + break _hb; + } + } + case 30: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 31: + { + { + _hs[0] = 20007; + break _hb; + } + } + case 32: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 33: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 34: + { + { + _hs[0] = 20008; + break _hb; + } + } + case 35: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 36: + { + { + _hs[0] = 30000; + break _hb; + } + } + case 37: + { + { + _hs[0] = 30003; + break _hb; + } + } + case 38: + { + { + _hs[0] = 30004; + break _hb; + } + } + case 39: + { + { + _hs[0] = 30005; + break _hb; + } + } + case 40: + { + { + _hs[0] = 30006; + break _hb; + } + } + case 41: + { + break label_62; + } + case 42: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 43: + { + { + _hs[0] = 40000; + break _hb; + } + } + case 44: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 45: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 46: + { + { + _hs[0] = 40011; + break _hb; + } + } + case 47: + { + { + _hs[0] = 10004; + break _hb; + } + } + case 48: + { + { + _hs[0] = 10005; + break _hb; + } + } + case 49: + { + { + _hs[0] = 3; + break _hb; + } + } + case 50: + { + break label_60; + } + case 51: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 52: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 53: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 54: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 55: + { + { + _hs[0] = 40015; + break _hb; + } + } + case 56: + { + { + _hs[0] = 20009; + break _hb; + } + } + case 57: + { + { + _hs[0] = 30007; + break _hb; + } + } + case 58: + { + { + _hs[0] = 30008; + break _hb; + } + } + case 59: + { + { + _hs[0] = 30009; + break _hb; + } + } + case 60: + { + { + _hs[0] = 30010; + break _hb; + } + } + case 61: + { + { + _hs[0] = 30011; + break _hb; + } + } + case 62: + { + { + _hs[0] = 30012; + break _hb; + } + } + case 63: + { + { + _hs[0] = 30013; + break _hb; + } + } + case 64: + { + { + _hs[0] = 40016; + break _hb; + } + } + case 65: + { + { + _hs[0] = 40017; + break _hb; + } + } + case 66: + { + { + _hs[0] = 40018; + break _hb; + } + } + case 67: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 68: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 69: + { + { + _hs[0] = 20010; + break _hb; + } + } + case 70: + { + break label_63; + } + default: + { + { + _hs[0] = 40008; + break _hb; + } + } + } + } + iL[0] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[0] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 40019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (byte) ((iL[0] ^ 1))); + long[] callArgs_2 = new long[1]; + callArgs_2[0] = ((long) 36); + long[] callResult_2 = instance.getMachine().call(1776, callArgs_2); + iL[0] = ((int) callResult_2[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 64); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 51796); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) (iL[2] + 1696) < 0 ? (iL[2] + 1696) : (iL[2] + 1696) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) (iL[2] + 1704) < 0 ? (iL[2] + 1704) : (iL[2] + 1704) + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 40020; + break _hb; + } + } + int ciTableIdx_3 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_3 = instance.table(0).requiredRef(ciTableIdx_3); + com.dylibso.chicory.runtime.Instance ciRefInstance_3 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_3), instance); + if (!ciRefInstance_3.type(ciRefInstance_3.functionType(ciFuncId_3)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_3 = new long[1]; + callArgs_3[0] = ((long) iL[3]); + ciRefInstance_3.getMachine().call(ciFuncId_3, callArgs_3); + { + _hs[0] = 40020; + break _hb; + } + } + iL[0] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[0] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 40019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (byte) ((iL[0] ^ 1))); + long[] callArgs_4 = new long[1]; + callArgs_4[0] = ((long) 36); + long[] callResult_4 = instance.getMachine().call(1776, callArgs_4); + iL[0] = ((int) callResult_4[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 34); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 51864); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) (iL[2] + 1696) < 0 ? (iL[2] + 1696) : (iL[2] + 1696) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) (iL[2] + 1704) < 0 ? (iL[2] + 1704) : (iL[2] + 1704) + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 40020; + break _hb; + } + } + int ciTableIdx_5 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_5 = instance.table(0).requiredRef(ciTableIdx_5); + com.dylibso.chicory.runtime.Instance ciRefInstance_5 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_5), instance); + if (!ciRefInstance_5.type(ciRefInstance_5.functionType(ciFuncId_5)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_5 = new long[1]; + callArgs_5[0] = ((long) iL[3]); + ciRefInstance_5.getMachine().call(ciFuncId_5, callArgs_5); + { + _hs[0] = 40020; + break _hb; + } + } + iL[0] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[0] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 40019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[4] < 0 ? iL[4] : iL[4] + 0, (byte) ((iL[0] ^ 1))); + long[] callArgs_6 = new long[1]; + callArgs_6[0] = ((long) 36); + long[] callResult_6 = instance.getMachine().call(1776, callArgs_6); + iL[0] = ((int) callResult_6[0]); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 4, (long) 0L); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 32, (int) 19); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) 51932); + memory.writeLong((int) iL[0] < 0 ? iL[0] : iL[0] + 12, (long) memory.readLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1688)); + memory.writeLong((int) (iL[0] + 20) < 0 ? (iL[0] + 20) : (iL[0] + 20) + 0, (long) memory.readLong((int) (iL[2] + 1696) < 0 ? (iL[2] + 1696) : (iL[2] + 1696) + 0)); + memory.writeI32((int) (iL[0] + 28) < 0 ? (iL[0] + 28) : (iL[0] + 28) + 0, (int) memory.readInt((int) (iL[2] + 1704) < 0 ? (iL[2] + 1704) : (iL[2] + 1704) + 0)); + iL[3] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + { + _hs[0] = 40020; + break _hb; + } + } + int ciTableIdx_7 = (int) (memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 4)); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) iL[3]); + ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + { + _hs[0] = 40020; + break _hb; + } + } + iL[5] = ((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 0) & 0xFF); + iL[3] = (iL[3] + (iL[5] * 40)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[3] < 0 ? iL[3] : iL[3] + 36) & 0xFF)) != 0) { + { + _hs[0] = 40019; + break _hb; + } + } + memory.writeByte((int) (iL[3] + 36) < 0 ? (iL[3] + 36) : (iL[3] + 36) + 0, (byte) (0)); + memory.writeByte((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (byte) ((iL[5] ^ 1))); + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 1528, (int) 0); + memory.writeLong((int) iL[2] < 0 ? iL[2] : iL[2] + 1520, (long) 0L); + label_64: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 12) + 10) & 0xFF)) != 0) { + break label_64; + } + long[] callArgs_8 = new long[2]; + callArgs_8[1] = ((long) 43); + callArgs_8[0] = ((long) iL[0]); + long[] callResult_8 = instance.getMachine().call(1155, callArgs_8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_8[0])) != 0) { + break label_64; + } + long[] callArgs_9 = new long[4]; + callArgs_9[3] = ((long) 0); + callArgs_9[2] = ((long) (iL[2] + 1520)); + callArgs_9[1] = ((long) 43); + callArgs_9[0] = ((long) iL[0]); + long[] callResult_9 = instance.getMachine().call(1238, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, ((int) callResult_9[0])) != 0) { + break label_64; + } + iL[0] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 1520); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + { + _hs[0] = 40021; + break _hb; + } + } + long[] callArgs_10 = new long[1]; + callArgs_10[0] = ((long) iL[0]); + instance.getMachine().call(1777, callArgs_10); + { + _hs[0] = 40021; + break _hb; + } + } + long[] callArgs_11 = new long[1]; + callArgs_11[0] = ((long) 48); + long[] callResult_11 = instance.getMachine().call(1776, callArgs_11); + long[] callArgs_12 = new long[2]; + callArgs_12[1] = ((long) (iL[2] + 1520)); + callArgs_12[0] = ((long) (iL[2] + 1672)); + long[] callResult_12 = instance.getMachine().call(1258, callArgs_12); + iL[3] = ((int) callResult_12[0]); + long[] callArgs_13 = new long[3]; + callArgs_13[2] = ((long) (iL[2] + 1688)); + callArgs_13[1] = ((long) iL[3]); + callArgs_13[0] = ((long) ((int) callResult_11[0])); + long[] callResult_13 = instance.getMachine().call(1259, callArgs_13); + iL[5] = ((int) callResult_13[0]); + iL[0] = memory.readInt((int) iL[1] < 0 ? iL[1] : iL[1] + 0); + memory.writeI32((int) iL[1] < 0 ? iL[1] : iL[1] + 0, (int) iL[5]); + label_65: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_65; + } + int ciTableIdx_14 = (int) (memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + int ciFuncId_14 = instance.table(0).requiredRef(ciTableIdx_14); + com.dylibso.chicory.runtime.Instance ciRefInstance_14 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_14), instance); + if (!ciRefInstance_14.type(ciRefInstance_14.functionType(ciFuncId_14)).typesMatch(instance.type(0))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_14 = new long[1]; + callArgs_14[0] = ((long) iL[0]); + ciRefInstance_14.getMachine().call(ciFuncId_14, callArgs_14); + } + label_66: { + iL[0] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + break label_66; + } + memory.writeI32((int) iL[3] < 0 ? iL[3] : iL[3] + 4, (int) iL[0]); + long[] callArgs_15 = new long[1]; + callArgs_15[0] = ((long) iL[0]); + instance.getMachine().call(1777, callArgs_15); + } + iL[0] = memory.readInt((int) iL[2] < 0 ? iL[2] : iL[2] + 1520); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[0]) != 0) { + { + _hs[0] = 40020; + break _hb; + } + } + memory.writeI32((int) iL[2] < 0 ? iL[2] : iL[2] + 1524, (int) iL[0]); + long[] callArgs_16 = new long[1]; + callArgs_16[0] = ((long) iL[0]); + instance.getMachine().call(1777, callArgs_16); + { + _hs[0] = 40020; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_41__h6(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[30] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 196); + iL[26] = memory.readInt((int) (iL[24] + 200) < 0 ? (iL[24] + 200) : (iL[24] + 200) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[26], iL[30]) != 0) { + break _hb; + } + label_215: while (true) { + iL[24] = ((int) memory.read((int) iL[30] < 0 ? iL[30] : iL[30] + 11) & 0xFF); + iL[37] = com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(com.dylibso.chicory.runtime.OpcodeImpl.I32_EXTEND_8_S(iL[24]), 0); + iL[31] = (iL[37] != 0 ? memory.readInt((int) iL[30] < 0 ? iL[30] : iL[30] + 0) : iL[30]); + label_216: { + label_217: { + label_218: { + label_219: { + iL[25] = (iL[37] != 0 ? memory.readInt((int) iL[30] < 0 ? iL[30] : iL[30] + 4) : iL[24]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(4, iL[25]) != 0) { + break label_219; + } + label_220: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1701667182, memory.readInt((int) iL[31] < 0 ? iL[31] : iL[31] + 0)) != 0) { + break label_220; + } + if (((int) memory.read((int) memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) < 0 ? memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) : memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 21) & 0xFF) != 0) { + break label_216; + } + } + iL[38] = (iL[31] + iL[25]); + break label_218; + } + iL[38] = (iL[31] + iL[25]); + iL[27] = iL[31]; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[25]) != 0) { + break label_217; + } + } + iL[37] = iL[31]; + iL[27] = iL[38]; + label_221: while (true) { + iL[24] = (iL[37] + 4); + label_222: while (true) { + iL[37] = (iL[24] + -3); + label_223: { + iL[36] = (iL[24] + -4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(114, ((int) memory.read((int) iL[36] < 0 ? iL[36] : iL[36] + 0) & 0xFF)) != 0) { + break label_223; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[37]) != 0) { + break label_217; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(101, ((int) memory.read((int) iL[37] < 0 ? iL[37] : iL[37] + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_221; + } + iL[28] = (iL[24] + -2); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[28]) != 0) { + break label_217; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(108, ((int) memory.read((int) iL[28] < 0 ? iL[28] : iL[28] + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_221; + } + iL[28] = (iL[24] + -1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[28]) != 0) { + break label_217; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(111, ((int) memory.read((int) iL[28] < 0 ? iL[28] : iL[28] + 0) & 0xFF)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_221; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[24]) != 0) { + break label_217; + } + iL[37] = (iL[24] + -3); + iL[27] = (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(99, ((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 0) & 0xFF)) != 0 ? iL[36] : iL[27]); + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_221; + } + iL[24] = (iL[24] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[38], iL[37]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_222; + } + break; + } + break; + } + } + label_224: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[27]) != 0) { + break label_224; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[31], iL[27]) != 0) { + break label_224; + } + if (((int) memory.read((int) memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) < 0 ? memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) : memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 20) & 0xFF) != 0) { + break label_216; + } + } + label_225: { + label_226: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(7, iL[25]) != 0) { + break label_226; + } + long[] callArgs_219 = new long[3]; + callArgs_219[2] = ((long) 7); + callArgs_219[1] = ((long) 14424); + callArgs_219[0] = ((long) iL[31]); + long[] callResult_219 = instance.getMachine().call(1889, callArgs_219); + if (((int) callResult_219[0]) != 0) { + break label_225; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) < 0 ? memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) : memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 20) & 0xFF)) != 0) { + break label_225; + } + break label_216; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[25], 14) != 0) { + break label_225; + } + iL[24] = iL[31]; + label_227: while (true) { + long[] callArgs_220 = new long[3]; + callArgs_220[2] = ((long) (iL[25] + -13)); + callArgs_220[1] = ((long) 109); + callArgs_220[0] = ((long) iL[24]); + long[] callResult_220 = instance.getMachine().call(1888, callArgs_220); + iL[24] = ((int) callResult_220[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_225; + } + label_228: { + long[] callArgs_221 = new long[3]; + callArgs_221[2] = ((long) 14); + callArgs_221[1] = ((long) 29082); + callArgs_221[0] = ((long) iL[24]); + long[] callResult_221 = instance.getMachine().call(1889, callArgs_221); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_221[0])) != 0) { + break label_228; + } + iL[24] = (iL[24] + 1); + iL[25] = (iL[38] - iL[24]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_S(iL[25], 14) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_227; + } + break label_225; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[24]) != 0) { + break label_225; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[31], iL[24]) != 0) { + break label_225; + } + if (((int) memory.read((int) memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) < 0 ? memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) : memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 12) & 0xFF) != 0) { + break label_216; + } + } + long[] callArgs_222 = new long[2]; + callArgs_222[1] = ((long) iL[31]); + callArgs_222[0] = ((long) iL[0]); + instance.getMachine().call(52, callArgs_222); + label_229: { + iL[24] = memory.readInt((int) (iL[30] + 16) < 0 ? (iL[30] + 16) : (iL[30] + 16) + 0); + iL[37] = memory.readInt((int) iL[30] < 0 ? iL[30] : iL[30] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[37], iL[24]) != 0) { + break label_229; + } + iL[24] = (iL[24] - iL[37]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[24], -1) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + long[] callArgs_223 = new long[1]; + callArgs_223[0] = ((long) iL[24]); + long[] callResult_223 = instance.getMachine().call(1776, callArgs_223); + iL[25] = ((int) callResult_223[0]); + label_230: { + iL[24] = memory.readInt((int) iL[30] < 0 ? iL[30] : iL[30] + 12); + iL[36] = memory.readInt((int) iL[30] < 0 ? iL[30] : iL[30] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_230; + } + iL[27] = ((iL[24] ^ -1) + iL[36]); + label_231: { + label_232: { + iL[38] = ((iL[36] - iL[24]) & 7); + if (iL[38] != 0) { + break label_232; + } + iL[37] = iL[25]; + break label_231; + } + iL[37] = iL[25]; + label_233: while (true) { + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 0) & 0xFF))); + iL[37] = (iL[37] + 1); + iL[24] = (iL[24] + 1); + iL[38] = (iL[38] + -1); + if (iL[38] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_233; + } + break; + } + } + label_234: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[27], 7) != 0) { + break label_234; + } + label_235: while (true) { + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 0) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 1, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 1) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 2, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 2) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 3, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 3) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 4, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 4) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 5, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 5) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 6, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 6) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 7, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 7) & 0xFF))); + iL[37] = (iL[37] + 8); + iL[24] = (iL[24] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_235; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[37], iL[25]) != 0) { + break label_230; + } + long[] callArgs_224 = new long[5]; + callArgs_224[4] = ((long) 0); + callArgs_224[3] = ((long) 26735); + callArgs_224[2] = ((long) (iL[37] - iL[25])); + callArgs_224[1] = ((long) iL[25]); + callArgs_224[0] = ((long) iL[31]); + instance.getMachine().call(224, callArgs_224); + } + long[] callArgs_225 = new long[1]; + callArgs_225[0] = ((long) iL[25]); + instance.getMachine().call(1777, callArgs_225); + } + long[] callArgs_226 = new long[4]; + callArgs_226[3] = ((long) 15012); + callArgs_226[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_226[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_226[0] = ((long) iL[0]); + long[] callResult_226 = instance.getMachine().call(48, callArgs_226); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + } + iL[30] = (iL[30] + 44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[26], iL[30]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_215; + } + break; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h18(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_124: { + label_125: { + label_126: { + label_127: { + label_128: { + switch((memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3216) + -1)) { + case 0: + { + break label_128; + } + case 1: + { + break label_127; + } + case 2: + { + break label_124; + } + case 3: + { + break label_126; + } + default: + { + { + _hs[0] = 1; + break _hb; + } + } + } + } + label_129: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_100 = new long[3]; + callArgs_100[2] = ((long) (iL[4] + 3168)); + callArgs_100[1] = ((long) (iL[15] + iL[3])); + callArgs_100[0] = ((long) (iL[15] + iL[13])); + long[] callResult_100 = instance.getMachine().call(177, callArgs_100); + iL[15] = ((int) callResult_100[0]); + if (iL[15] != 0) { + break label_129; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1360, (int) 14889); + long[] callArgs_101 = new long[3]; + callArgs_101[2] = ((long) (iL[4] + 1360)); + callArgs_101[1] = ((long) 11260); + callArgs_101[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_101); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[15] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[15]); + label_130: { + long[] callArgs_102 = new long[3]; + callArgs_102[2] = ((long) (iL[4] + 3248)); + callArgs_102[1] = ((long) (iL[13] + iL[16])); + callArgs_102[0] = ((long) (iL[13] + iL[15])); + long[] callResult_102 = instance.getMachine().call(177, callArgs_102); + iL[15] = ((int) callResult_102[0]); + if (iL[15] != 0) { + break label_130; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1376, (int) 12938); + long[] callArgs_103 = new long[3]; + callArgs_103[2] = ((long) (iL[4] + 1376)); + callArgs_103[1] = ((long) 11260); + callArgs_103[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_103); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[15] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[15]); + label_131: { + long[] callArgs_104 = new long[3]; + callArgs_104[2] = ((long) (iL[4] + 3160)); + callArgs_104[1] = ((long) (iL[13] + iL[16])); + callArgs_104[0] = ((long) (iL[13] + iL[15])); + long[] callResult_104 = instance.getMachine().call(177, callArgs_104); + iL[15] = ((int) callResult_104[0]); + if (iL[15] != 0) { + break label_131; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1392, (int) 14898); + long[] callArgs_105 = new long[3]; + callArgs_105[2] = ((long) (iL[4] + 1392)); + callArgs_105[1] = ((long) 11260); + callArgs_105[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_105); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[15] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[15]); + label_132: { + long[] callArgs_106 = new long[3]; + callArgs_106[2] = ((long) (iL[4] + 3152)); + callArgs_106[1] = ((long) (iL[13] + iL[16])); + callArgs_106[0] = ((long) (iL[13] + iL[15])); + long[] callResult_106 = instance.getMachine().call(177, callArgs_106); + iL[13] = ((int) callResult_106[0]); + if (iL[13] != 0) { + break label_132; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1408, (int) 12948); + long[] callArgs_107 = new long[3]; + callArgs_107[2] = ((long) (iL[4] + 1408)); + callArgs_107[1] = ((long) 11260); + callArgs_107[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_107); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_108 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 744)); + int ciFuncId_108 = instance.table(0).requiredRef(ciTableIdx_108); + com.dylibso.chicory.runtime.Instance ciRefInstance_108 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_108), instance); + if (!ciRefInstance_108.type(ciRefInstance_108.functionType(ciFuncId_108)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_108 = new long[5]; + callArgs_108[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3152)); + callArgs_108[3] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160)); + callArgs_108[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3248)); + callArgs_108[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168)); + callArgs_108[0] = ((long) iL[13]); + long[] callResult_108 = ciRefInstance_108.getMachine().call(ciFuncId_108, callArgs_108); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_108[0])) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + long[] callArgs_109 = new long[3]; + callArgs_109[2] = ((long) 0); + callArgs_109[1] = ((long) 22925); + callArgs_109[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_109); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + label_133: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_110 = new long[3]; + callArgs_110[2] = ((long) (iL[4] + 3208)); + callArgs_110[1] = ((long) (iL[15] + iL[3])); + callArgs_110[0] = ((long) (iL[15] + iL[13])); + long[] callResult_110 = instance.getMachine().call(177, callArgs_110); + iL[13] = ((int) callResult_110[0]); + if (iL[13] != 0) { + break label_133; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1424, (int) 8776); + long[] callArgs_111 = new long[3]; + callArgs_111[2] = ((long) (iL[4] + 1424)); + callArgs_111[1] = ((long) 11260); + callArgs_111[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_111); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_112 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 764)); + int ciFuncId_112 = instance.table(0).requiredRef(ciTableIdx_112); + com.dylibso.chicory.runtime.Instance ciRefInstance_112 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_112), instance); + if (!ciRefInstance_112.type(ciRefInstance_112.functionType(ciFuncId_112)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_112 = new long[2]; + callArgs_112[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3208)); + callArgs_112[0] = ((long) iL[13]); + long[] callResult_112 = ciRefInstance_112.getMachine().call(ciFuncId_112, callArgs_112); + if (((int) callResult_112[0]) != 0) { + break label_125; + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3208); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3208, (int) (iL[13] + -1)); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + label_134: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_113 = new long[3]; + callArgs_113[2] = ((long) 16783); + callArgs_113[1] = ((long) (iL[4] + 3168)); + callArgs_113[0] = ((long) (iL[4] + 2936)); + long[] callResult_113 = instance.getMachine().call(803, callArgs_113); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_113[0])) != 0) { + { + _hs[0] = 40005; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[15] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 768); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1432, (long) lL[0]); + label_135: { + int ciTableIdx_114 = (int) (iL[15]); + int ciFuncId_114 = instance.table(0).requiredRef(ciTableIdx_114); + com.dylibso.chicory.runtime.Instance ciRefInstance_114 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_114), instance); + if (!ciRefInstance_114.type(ciRefInstance_114.functionType(ciFuncId_114)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_114 = new long[2]; + callArgs_114[1] = ((long) (iL[4] + 1432)); + callArgs_114[0] = ((long) iL[13]); + long[] callResult_114 = ciRefInstance_114.getMachine().call(ciFuncId_114, callArgs_114); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_114[0])) != 0) { + break label_135; + } + long[] callArgs_115 = new long[3]; + callArgs_115[2] = ((long) 0); + callArgs_115[1] = ((long) 25555); + callArgs_115[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_115); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3208); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3208, (int) (iL[13] + -1)); + if (iL[13] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_134; + } + { + _hs[0] = 2; + break _hb; + } + } + } + label_136: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_116 = new long[3]; + callArgs_116[2] = ((long) (iL[4] + 3208)); + callArgs_116[1] = ((long) (iL[15] + iL[3])); + callArgs_116[0] = ((long) (iL[15] + iL[13])); + long[] callResult_116 = instance.getMachine().call(177, callArgs_116); + iL[13] = ((int) callResult_116[0]); + if (iL[13] != 0) { + break label_136; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1440, (int) 6683); + long[] callArgs_117 = new long[3]; + callArgs_117[2] = ((long) (iL[4] + 1440)); + callArgs_117[1] = ((long) 11260); + callArgs_117[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_117); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_118 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 748)); + int ciFuncId_118 = instance.table(0).requiredRef(ciTableIdx_118); + com.dylibso.chicory.runtime.Instance ciRefInstance_118 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_118), instance); + if (!ciRefInstance_118.type(ciRefInstance_118.functionType(ciFuncId_118)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_118 = new long[2]; + callArgs_118[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3208)); + callArgs_118[0] = ((long) iL[13]); + long[] callResult_118 = ciRefInstance_118.getMachine().call(ciFuncId_118, callArgs_118); + if (((int) callResult_118[0]) != 0) { + break _hb; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3208)) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + iL[13] = 0; + label_137: while (true) { + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3160, (int) 0); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3248, (long) 0L); + long[] callArgs_119 = new long[3]; + callArgs_119[2] = ((long) 17144); + callArgs_119[1] = ((long) (iL[4] + 3168)); + callArgs_119[0] = ((long) (iL[4] + 2936)); + long[] callResult_119 = instance.getMachine().call(803, callArgs_119); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_119[0])) != 0) { + { + _hs[0] = 40005; + break _hb; + } + } + long[] callArgs_120 = new long[3]; + callArgs_120[2] = ((long) 17894); + callArgs_120[1] = ((long) (iL[4] + 3248)); + callArgs_120[0] = ((long) (iL[4] + 2936)); + long[] callResult_120 = instance.getMachine().call(803, callArgs_120); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_120[0])) != 0) { + { + _hs[0] = 40005; + break _hb; + } + } + label_138: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_121 = new long[3]; + callArgs_121[2] = ((long) (iL[4] + 3160)); + callArgs_121[1] = ((long) (iL[15] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_121[0] = ((long) (iL[15] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_121 = instance.getMachine().call(177, callArgs_121); + iL[15] = ((int) callResult_121[0]); + if (iL[15] != 0) { + break label_138; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1456, (int) 8329); + long[] callArgs_122 = new long[3]; + callArgs_122[2] = ((long) (iL[4] + 1456)); + callArgs_122[1] = ((long) 11260); + callArgs_122[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_122); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3240, (long) lL[0]); + lL[1] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3248); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3232, (long) lL[1]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15])); + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[16] = memory.readInt((int) memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) < 0 ? memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) : memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) + 756); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1480, (long) lL[0]); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1472, (long) lL[1]); + label_139: { + int ciTableIdx_123 = (int) (iL[16]); + int ciFuncId_123 = instance.table(0).requiredRef(ciTableIdx_123); + com.dylibso.chicory.runtime.Instance ciRefInstance_123 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_123), instance); + if (!ciRefInstance_123.type(ciRefInstance_123.functionType(ciFuncId_123)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_123 = new long[4]; + callArgs_123[3] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160)); + callArgs_123[2] = ((long) (iL[4] + 1472)); + callArgs_123[1] = ((long) (iL[4] + 1480)); + callArgs_123[0] = ((long) iL[15]); + long[] callResult_123 = ciRefInstance_123.getMachine().call(ciFuncId_123, callArgs_123); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_123[0])) != 0) { + break label_139; + } + long[] callArgs_124 = new long[3]; + callArgs_124[2] = ((long) 0); + callArgs_124[1] = ((long) 19192); + callArgs_124[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_124); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + iL[13] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[13], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3208)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_137; + } + { + _hs[0] = 2; + break _hb; + } + } + } + long[] callArgs_125 = new long[3]; + callArgs_125[2] = ((long) 0); + callArgs_125[1] = ((long) 20019); + callArgs_125[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_125); + { + _hs[0] = 40005; + break _hb; + } + } + label_140: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_126 = new long[3]; + callArgs_126[2] = ((long) (iL[4] + 3208)); + callArgs_126[1] = ((long) (iL[15] + iL[3])); + callArgs_126[0] = ((long) (iL[15] + iL[13])); + long[] callResult_126 = instance.getMachine().call(177, callArgs_126); + iL[13] = ((int) callResult_126[0]); + if (iL[13] != 0) { + break label_140; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1488, (int) 6683); + long[] callArgs_127 = new long[3]; + callArgs_127[2] = ((long) (iL[4] + 1488)); + callArgs_127[1] = ((long) 11260); + callArgs_127[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_127); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + label_141: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_128 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 752)); + int ciFuncId_128 = instance.table(0).requiredRef(ciTableIdx_128); + com.dylibso.chicory.runtime.Instance ciRefInstance_128 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_128), instance); + if (!ciRefInstance_128.type(ciRefInstance_128.functionType(ciFuncId_128)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_128 = new long[2]; + callArgs_128[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3208)); + callArgs_128[0] = ((long) iL[13]); + long[] callResult_128 = ciRefInstance_128.getMachine().call(ciFuncId_128, callArgs_128); + if (((int) callResult_128[0]) != 0) { + break label_141; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3208)) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + iL[13] = 0; + label_142: while (true) { + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3248, (int) 0); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_129 = new long[3]; + callArgs_129[2] = ((long) 16984); + callArgs_129[1] = ((long) (iL[4] + 3168)); + callArgs_129[0] = ((long) (iL[4] + 2936)); + long[] callResult_129 = instance.getMachine().call(803, callArgs_129); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_129[0])) != 0) { + { + _hs[0] = 40005; + break _hb; + } + } + label_143: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_130 = new long[3]; + callArgs_130[2] = ((long) (iL[4] + 3248)); + callArgs_130[1] = ((long) (iL[15] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_130[0] = ((long) (iL[15] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_130 = instance.getMachine().call(177, callArgs_130); + iL[15] = ((int) callResult_130[0]); + if (iL[15] != 0) { + break label_143; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1504, (int) 8329); + long[] callArgs_131 = new long[3]; + callArgs_131[2] = ((long) (iL[4] + 1504)); + callArgs_131[1] = ((long) 11260); + callArgs_131[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_131); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3224, (long) lL[0]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15])); + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[16] = memory.readInt((int) memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) < 0 ? memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) : memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) + 760); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1512, (long) lL[0]); + label_144: { + int ciTableIdx_132 = (int) (iL[16]); + int ciFuncId_132 = instance.table(0).requiredRef(ciTableIdx_132); + com.dylibso.chicory.runtime.Instance ciRefInstance_132 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_132), instance); + if (!ciRefInstance_132.type(ciRefInstance_132.functionType(ciFuncId_132)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_132 = new long[3]; + callArgs_132[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3248)); + callArgs_132[1] = ((long) (iL[4] + 1512)); + callArgs_132[0] = ((long) iL[15]); + long[] callResult_132 = ciRefInstance_132.getMachine().call(ciFuncId_132, callArgs_132); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_132[0])) != 0) { + break label_144; + } + long[] callArgs_133 = new long[3]; + callArgs_133[2] = ((long) 0); + callArgs_133[1] = ((long) 19136); + callArgs_133[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_133); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } + iL[13] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[13], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3208)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_142; + } + { + _hs[0] = 2; + break _hb; + } + } + } + long[] callArgs_134 = new long[3]; + callArgs_134[2] = ((long) 0); + callArgs_134[1] = ((long) 19319); + callArgs_134[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_134); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 40002; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_804__h15(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_129: { + label_130: { + label_131: { + int _d14 = func_804__h14(iL, lL, memory, instance); + if (_d14 == 1) { + _hs[0] = 1; + break _hb; + } + if (_d14 == 2) + break label_129; + if (_d14 == 3) + break _hb; + if (_d14 == 4) { + _hs[0] = 2; + break _hb; + } + if (_d14 == 5) { + _hs[0] = 3; + break _hb; + } + if (_d14 == 6) + break label_130; + if (_d14 >= 10000) { + _hs[0] = ((_d14 - 10000)) + 10000; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_31 = new long[3]; + callArgs_31[2] = ((long) 8481); + callArgs_31[1] = ((long) (iL[3] + 336)); + callArgs_31[0] = ((long) iL[0]); + long[] callResult_31 = instance.getMachine().call(813, callArgs_31); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_31[0])) != 0) { + { + _hs[0] = 40007; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 336); + long[] callArgs_32 = new long[2]; + callArgs_32[1] = ((long) iL[13]); + callArgs_32[0] = ((long) iL[5]); + instance.getMachine().call(816, callArgs_32); + label_147: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_147; + } + iL[4] = 0; + iL[12] = iL[13]; + label_148: while (true) { + long[] callArgs_33 = new long[3]; + callArgs_33[2] = ((long) 15776); + callArgs_33[1] = ((long) (iL[3] + 352)); + callArgs_33[0] = ((long) iL[0]); + long[] callResult_33 = instance.getMachine().call(805, callArgs_33); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_33[0])) != 0) { + { + _hs[0] = 40007; + break _hb; + } + } + iL[10] = memory.readInt((int) (iL[0] + 100) < 0 ? (iL[0] + 100) : (iL[0] + 100) + 0); + label_149: { + label_150: { + label_151: { + label_152: { + label_153: { + lL[0] = memory.readLong((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + iL[14] = (int) lL[0]; + switch((iL[14] + 23)) { + case 0: + { + break label_153; + } + case 1: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 2: + { + break label_152; + } + case 3: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 4: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 5: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 6: + { + break label_150; + } + case 7: + { + break label_150; + } + case 8: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 9: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 10: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 11: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 12: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 13: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 14: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 15: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 16: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 17: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 18: + { + break label_151; + } + case 19: + { + break label_149; + } + case 20: + { + break label_149; + } + case 21: + { + break label_149; + } + case 22: + { + break label_149; + } + default: + { + { + _hs[0] = 40012; + break _hb; + } + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 0) & 0xFF)) != 0) { + { + _hs[0] = 40012; + break _hb; + } + } + break label_149; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 6) & 0xFF)) != 0) { + { + _hs[0] = 40012; + break _hb; + } + } + break label_149; + } + if (((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 4) & 0xFF) != 0) { + break label_149; + } + { + _hs[0] = 40012; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[10] < 0 ? iL[10] : iL[10] + 10) & 0xFF)) != 0) { + { + _hs[0] = 40012; + break _hb; + } + } + } + memory.writeLong((int) (memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + iL[4]) < 0 ? (memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + iL[4]) : (memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + iL[4]) + 0, (long) lL[0]); + iL[4] = (iL[4] + 8); + iL[12] = (iL[12] + -1); + if (iL[12] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_148; + } + break; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_147; + } + label_154: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_34 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 512)); + int ciFuncId_34 = instance.table(0).requiredRef(ciTableIdx_34); + com.dylibso.chicory.runtime.Instance ciRefInstance_34 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_34), instance); + if (!ciRefInstance_34.type(ciRefInstance_34.functionType(ciFuncId_34)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_34 = new long[3]; + callArgs_34[2] = ((long) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0)); + callArgs_34[1] = ((long) iL[13]); + callArgs_34[0] = ((long) iL[4]); + long[] callResult_34 = ciRefInstance_34.getMachine().call(ciFuncId_34, callArgs_34); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_34[0])) != 0) { + break label_154; + } + long[] callArgs_35 = new long[3]; + callArgs_35[2] = ((long) 0); + callArgs_35[1] = ((long) 21492); + callArgs_35[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_35); + { + _hs[0] = 40007; + break _hb; + } + } + lL[0] = memory.readLong((int) memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) < 0 ? memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) : memory.readInt((int) iL[5] < 0 ? iL[5] : iL[5] + 0) + 0); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 368, (long) lL[0]); + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 276); + memory.writeLong((int) iL[3] < 0 ? iL[3] : iL[3] + 104, (long) lL[0]); + int ciTableIdx_36 = (int) (iL[12]); + int ciFuncId_36 = instance.table(0).requiredRef(ciTableIdx_36); + com.dylibso.chicory.runtime.Instance ciRefInstance_36 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_36), instance); + if (!ciRefInstance_36.type(ciRefInstance_36.functionType(ciFuncId_36)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_36 = new long[2]; + callArgs_36[1] = ((long) (iL[3] + 104)); + callArgs_36[0] = ((long) iL[4]); + long[] callResult_36 = ciRefInstance_36.getMachine().call(ciFuncId_36, callArgs_36); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_36[0])) != 0) { + { + _hs[0] = 40008; + break _hb; + } + } + long[] callArgs_37 = new long[3]; + callArgs_37[2] = ((long) 0); + callArgs_37[1] = ((long) 25278); + callArgs_37[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_37); + { + _hs[0] = 40007; + break _hb; + } + } + label_155: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_38 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 512)); + int ciFuncId_38 = instance.table(0).requiredRef(ciTableIdx_38); + com.dylibso.chicory.runtime.Instance ciRefInstance_38 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_38), instance); + if (!ciRefInstance_38.type(ciRefInstance_38.functionType(ciFuncId_38)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_38 = new long[3]; + callArgs_38[2] = ((long) 0); + callArgs_38[1] = ((long) 0); + callArgs_38[0] = ((long) iL[4]); + long[] callResult_38 = ciRefInstance_38.getMachine().call(ciFuncId_38, callArgs_38); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_38[0])) != 0) { + break label_155; + } + long[] callArgs_39 = new long[3]; + callArgs_39[2] = ((long) 0); + callArgs_39[1] = ((long) 21492); + callArgs_39[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_39); + { + _hs[0] = 40007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_40 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_40 = instance.table(0).requiredRef(ciTableIdx_40); + com.dylibso.chicory.runtime.Instance ciRefInstance_40 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_40), instance); + if (!ciRefInstance_40.type(ciRefInstance_40.functionType(ciFuncId_40)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_40 = new long[1]; + callArgs_40[0] = ((long) iL[4]); + long[] callResult_40 = ciRefInstance_40.getMachine().call(ciFuncId_40, callArgs_40); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_40[0])) != 0) { + { + _hs[0] = 40008; + break _hb; + } + } + long[] callArgs_41 = new long[3]; + callArgs_41[2] = ((long) 0); + callArgs_41[1] = ((long) 25128); + callArgs_41[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_41); + { + _hs[0] = 40007; + break _hb; + } + } + label_156: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_42 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 512)); + int ciFuncId_42 = instance.table(0).requiredRef(ciTableIdx_42); + com.dylibso.chicory.runtime.Instance ciRefInstance_42 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_42), instance); + if (!ciRefInstance_42.type(ciRefInstance_42.functionType(ciFuncId_42)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_42 = new long[3]; + callArgs_42[2] = ((long) 0); + callArgs_42[1] = ((long) 0); + callArgs_42[0] = ((long) iL[4]); + long[] callResult_42 = ciRefInstance_42.getMachine().call(ciFuncId_42, callArgs_42); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_42[0])) != 0) { + break label_156; + } + long[] callArgs_43 = new long[3]; + callArgs_43[2] = ((long) 0); + callArgs_43[1] = ((long) 21492); + callArgs_43[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_43); + iL[11] = 1; + { + _hs[0] = 40007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_44 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_44 = instance.table(0).requiredRef(ciTableIdx_44); + com.dylibso.chicory.runtime.Instance ciRefInstance_44 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_44), instance); + if (!ciRefInstance_44.type(ciRefInstance_44.functionType(ciFuncId_44)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_44 = new long[1]; + callArgs_44[0] = ((long) iL[4]); + long[] callResult_44 = ciRefInstance_44.getMachine().call(ciFuncId_44, callArgs_44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_44[0])) != 0) { + { + _hs[0] = 40008; + break _hb; + } + } + long[] callArgs_45 = new long[3]; + callArgs_45[2] = ((long) 0); + callArgs_45[1] = ((long) 25128); + callArgs_45[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_45); + iL[11] = 1; + { + _hs[0] = 40007; + break _hb; + } + } + iL[11] = 1; + long[] callArgs_46 = new long[3]; + callArgs_46[2] = ((long) 14127); + callArgs_46[1] = ((long) (iL[3] + 352)); + callArgs_46[0] = ((long) iL[0]); + long[] callResult_46 = instance.getMachine().call(814, callArgs_46); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_46[0])) != 0) { + { + _hs[0] = 40007; + break _hb; + } + } + label_157: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + iL[12] = memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 352); + int ciTableIdx_47 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 316)); + int ciFuncId_47 = instance.table(0).requiredRef(ciTableIdx_47); + com.dylibso.chicory.runtime.Instance ciRefInstance_47 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_47), instance); + if (!ciRefInstance_47.type(ciRefInstance_47.functionType(ciFuncId_47)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_47 = new long[2]; + callArgs_47[1] = ((long) iL[12]); + callArgs_47[0] = ((long) iL[4]); + long[] callResult_47 = ciRefInstance_47.getMachine().call(ciFuncId_47, callArgs_47); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_47[0])) != 0) { + break label_157; + } + iL[4] = 21553; + { + _hs[0] = 40013; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_48 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 236)); + int ciFuncId_48 = instance.table(0).requiredRef(ciTableIdx_48); + com.dylibso.chicory.runtime.Instance ciRefInstance_48 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_48), instance); + if (!ciRefInstance_48.type(ciRefInstance_48.functionType(ciFuncId_48)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_48 = new long[2]; + callArgs_48[1] = ((long) iL[12]); + callArgs_48[0] = ((long) iL[4]); + long[] callResult_48 = ciRefInstance_48.getMachine().call(ciFuncId_48, callArgs_48); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_48[0])) != 0) { + { + _hs[0] = 40008; + break _hb; + } + } + iL[4] = 19081; + { + _hs[0] = 40013; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h19(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3128); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[13], 5) != 0) { + break _hb; + } + label_469: { + label_470: { + label_471: { + label_472: { + if (((1 << iL[13]) & 53) != 0) { + break label_472; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(1, iL[13]) != 0) { + break label_469; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3120, (int) 0); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3112, (int) 0); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3104, (int) 0); + long[] callArgs_506 = new long[3]; + callArgs_506[2] = ((long) 16885); + callArgs_506[1] = ((long) (iL[4] + 3168)); + callArgs_506[0] = ((long) (iL[4] + 2936)); + long[] callResult_506 = instance.getMachine().call(803, callArgs_506); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_506[0])) != 0) { + { + _hs[0] = 30014; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160); + if ((iL[13] & 16) != 0) { + break label_470; + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_507 = new long[3]; + callArgs_507[2] = ((long) (iL[4] + 3120)); + callArgs_507[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_507[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_507 = instance.getMachine().call(177, callArgs_507); + iL[16] = ((int) callResult_507[0]); + if (iL[16] != 0) { + break label_471; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1040, (int) 7039); + long[] callArgs_508 = new long[3]; + callArgs_508[2] = ((long) (iL[4] + 1040)); + callArgs_508[1] = ((long) 11260); + callArgs_508[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_508); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3120, (int) 0); + label_473: { + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_509 = new long[3]; + callArgs_509[2] = ((long) (iL[4] + 3120)); + callArgs_509[1] = ((long) (iL[17] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_509[0] = ((long) (iL[17] + iL[16])); + long[] callResult_509 = instance.getMachine().call(177, callArgs_509); + iL[16] = ((int) callResult_509[0]); + if (iL[16] != 0) { + break label_473; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 992, (int) 2231); + long[] callArgs_510 = new long[3]; + callArgs_510[2] = ((long) (iL[4] + 992)); + callArgs_510[1] = ((long) 11260); + callArgs_510[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_510); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[16])); + label_474: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(16, (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160) & 80)) != 0) { + break label_474; + } + long[] callArgs_511 = new long[3]; + callArgs_511[2] = ((long) 16885); + callArgs_511[1] = ((long) (iL[4] + 3168)); + callArgs_511[0] = ((long) (iL[4] + 2936)); + long[] callResult_511 = instance.getMachine().call(803, callArgs_511); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_511[0])) != 0) { + { + _hs[0] = 30014; + break _hb; + } + } + } + label_475: { + label_476: { + label_477: { + label_478: { + label_479: { + switch(iL[13]) { + case 0: + { + break label_479; + } + case 1: + { + break label_475; + } + case 2: + { + break label_478; + } + case 3: + { + break label_475; + } + case 4: + { + break label_477; + } + case 5: + { + break label_476; + } + default: + { + break label_475; + } + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[16] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 816); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1008, (long) lL[0]); + int ciTableIdx_512 = (int) (iL[16]); + int ciFuncId_512 = instance.table(0).requiredRef(ciTableIdx_512); + com.dylibso.chicory.runtime.Instance ciRefInstance_512 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_512), instance); + if (!ciRefInstance_512.type(ciRefInstance_512.functionType(ciFuncId_512)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_512 = new long[5]; + callArgs_512[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3120)); + callArgs_512[3] = ((long) (iL[4] + 1008)); + callArgs_512[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160)); + callArgs_512[1] = ((long) iL[15]); + callArgs_512[0] = ((long) iL[13]); + long[] callResult_512 = ciRefInstance_512.getMachine().call(ciFuncId_512, callArgs_512); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_512[0])) != 0) { + break _hb; + } + long[] callArgs_513 = new long[3]; + callArgs_513[2] = ((long) 0); + callArgs_513[1] = ((long) 24745); + callArgs_513[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_513); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3248, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[16] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 820); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1016, (long) lL[0]); + int ciTableIdx_514 = (int) (iL[16]); + int ciFuncId_514 = instance.table(0).requiredRef(ciTableIdx_514); + com.dylibso.chicory.runtime.Instance ciRefInstance_514 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_514), instance); + if (!ciRefInstance_514.type(ciRefInstance_514.functionType(ciFuncId_514)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_514 = new long[5]; + callArgs_514[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3120)); + callArgs_514[3] = ((long) (iL[4] + 1016)); + callArgs_514[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160)); + callArgs_514[1] = ((long) iL[15]); + callArgs_514[0] = ((long) iL[13]); + long[] callResult_514 = ciRefInstance_514.getMachine().call(ciFuncId_514, callArgs_514); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_514[0])) != 0) { + break _hb; + } + long[] callArgs_515 = new long[3]; + callArgs_515[2] = ((long) 0); + callArgs_515[1] = ((long) 24810); + callArgs_515[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_515); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3240, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[16] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 828); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1024, (long) lL[0]); + int ciTableIdx_516 = (int) (iL[16]); + int ciFuncId_516 = instance.table(0).requiredRef(ciTableIdx_516); + com.dylibso.chicory.runtime.Instance ciRefInstance_516 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_516), instance); + if (!ciRefInstance_516.type(ciRefInstance_516.functionType(ciFuncId_516)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_516 = new long[5]; + callArgs_516[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3120)); + callArgs_516[3] = ((long) (iL[4] + 1024)); + callArgs_516[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160)); + callArgs_516[1] = ((long) iL[15]); + callArgs_516[0] = ((long) iL[13]); + long[] callResult_516 = ciRefInstance_516.getMachine().call(ciFuncId_516, callArgs_516); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_516[0])) != 0) { + break _hb; + } + long[] callArgs_517 = new long[3]; + callArgs_517[2] = ((long) 0); + callArgs_517[1] = ((long) 24841); + callArgs_517[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_517); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3232, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[16] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 832); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1032, (long) lL[0]); + int ciTableIdx_518 = (int) (iL[16]); + int ciFuncId_518 = instance.table(0).requiredRef(ciTableIdx_518); + com.dylibso.chicory.runtime.Instance ciRefInstance_518 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_518), instance); + if (!ciRefInstance_518.type(ciRefInstance_518.functionType(ciFuncId_518)).typesMatch(instance.type(8))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_518 = new long[5]; + callArgs_518[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3120)); + callArgs_518[3] = ((long) (iL[4] + 1032)); + callArgs_518[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160)); + callArgs_518[1] = ((long) iL[15]); + callArgs_518[0] = ((long) iL[13]); + long[] callResult_518 = ciRefInstance_518.getMachine().call(ciFuncId_518, callArgs_518); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_518[0])) != 0) { + break _hb; + } + long[] callArgs_519 = new long[3]; + callArgs_519[2] = ((long) 0); + callArgs_519[1] = ((long) 24869); + callArgs_519[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_519); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + instance.getMachine().call(1807, new long[0]); + throw new com.dylibso.chicory.runtime.TrapException("Trapped on unreachable instruction"); + } + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[16] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[16]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[16]); + label_480: { + long[] callArgs_521 = new long[3]; + callArgs_521[2] = ((long) (iL[4] + 3112)); + callArgs_521[1] = ((long) (iL[13] + iL[17])); + callArgs_521[0] = ((long) (iL[13] + iL[16])); + long[] callResult_521 = instance.getMachine().call(177, callArgs_521); + iL[16] = ((int) callResult_521[0]); + if (iL[16] != 0) { + break label_480; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1056, (int) 7295); + long[] callArgs_522 = new long[3]; + callArgs_522[2] = ((long) (iL[4] + 1056)); + callArgs_522[1] = ((long) 11260); + callArgs_522[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_522); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[16] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[16]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[16]); + label_481: { + long[] callArgs_523 = new long[3]; + callArgs_523[2] = ((long) (iL[4] + 3104)); + callArgs_523[1] = ((long) (iL[13] + iL[17])); + callArgs_523[0] = ((long) (iL[13] + iL[16])); + long[] callResult_523 = instance.getMachine().call(177, callArgs_523); + iL[13] = ((int) callResult_523[0]); + if (iL[13] != 0) { + break label_481; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1072, (int) 15192); + long[] callArgs_524 = new long[3]; + callArgs_524[2] = ((long) (iL[4] + 1072)); + callArgs_524[1] = ((long) 11260); + callArgs_524[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_524); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160); + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3224, (long) lL[0]); + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[17] = memory.readInt((int) memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) < 0 ? memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) : memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) + 812); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1080, (long) lL[0]); + int ciTableIdx_525 = (int) (iL[17]); + int ciFuncId_525 = instance.table(0).requiredRef(ciTableIdx_525); + com.dylibso.chicory.runtime.Instance ciRefInstance_525 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_525), instance); + if (!ciRefInstance_525.type(ciRefInstance_525.functionType(ciFuncId_525)).typesMatch(instance.type(9))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_525 = new long[7]; + callArgs_525[6] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3104)); + callArgs_525[5] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3112)); + callArgs_525[4] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3120)); + callArgs_525[3] = ((long) (iL[4] + 1080)); + callArgs_525[2] = ((long) iL[13]); + callArgs_525[1] = ((long) iL[15]); + callArgs_525[0] = ((long) iL[16]); + long[] callResult_525 = ciRefInstance_525.getMachine().call(ciFuncId_525, callArgs_525); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_525[0])) != 0) { + break _hb; + } + long[] callArgs_526 = new long[3]; + callArgs_526[2] = ((long) 0); + callArgs_526[1] = ((long) 24899); + callArgs_526[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_526); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3120, (int) 0); + label_482: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_527 = new long[3]; + callArgs_527[2] = ((long) (iL[4] + 3120)); + callArgs_527[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_527[0] = ((long) (iL[13] + iL[16])); + long[] callResult_527 = instance.getMachine().call(177, callArgs_527); + iL[13] = ((int) callResult_527[0]); + if (iL[13] != 0) { + break label_482; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1088, (int) 2231); + long[] callArgs_528 = new long[3]; + callArgs_528[2] = ((long) (iL[4] + 1088)); + callArgs_528[1] = ((long) 11260); + callArgs_528[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_528); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_529 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 824)); + int ciFuncId_529 = instance.table(0).requiredRef(ciTableIdx_529); + com.dylibso.chicory.runtime.Instance ciRefInstance_529 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_529), instance); + if (!ciRefInstance_529.type(ciRefInstance_529.functionType(ciFuncId_529)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_529 = new long[4]; + callArgs_529[3] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3120)); + callArgs_529[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3160)); + callArgs_529[1] = ((long) iL[15]); + callArgs_529[0] = ((long) iL[13]); + long[] callResult_529 = ciRefInstance_529.getMachine().call(ciFuncId_529, callArgs_529); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_529[0])) != 0) { + break _hb; + } + long[] callArgs_530 = new long[3]; + callArgs_530[2] = ((long) 0); + callArgs_530[1] = ((long) 24778); + callArgs_530[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_530); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 30002; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h20(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[3]) != 0) { + break _hb; + } + iL[0] = 0; + label_228: while (true) { + label_229: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_237 = new long[3]; + callArgs_237[2] = ((long) (iL[4] + 3240)); + callArgs_237[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_237[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_237 = instance.getMachine().call(177, callArgs_237); + iL[13] = ((int) callResult_237[0]); + if (iL[13] != 0) { + break label_229; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2368, (int) 8248); + long[] callArgs_238 = new long[3]; + callArgs_238[2] = ((long) (iL[4] + 2368)); + callArgs_238[1] = ((long) 11260); + callArgs_238[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_238); + { + _hs[0] = 1; + break _hb; + } + } + iL[15] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[15]); + label_230: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3240); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[13], 8) != 0) { + break label_230; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2384, (int) iL[13]); + long[] callArgs_239 = new long[3]; + callArgs_239[2] = ((long) (iL[4] + 2384)); + callArgs_239[1] = ((long) 2632); + callArgs_239[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_239); + { + _hs[0] = 1; + break _hb; + } + } + iL[14] = 0; + label_231: { + label_232: { + label_233: { + label_234: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(2, (iL[13] & 3)) != 0) { + break label_234; + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_240 = new long[3]; + callArgs_240[2] = ((long) (iL[4] + 3168)); + callArgs_240[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_240[0] = ((long) (iL[13] + iL[15])); + long[] callResult_240 = instance.getMachine().call(177, callArgs_240); + iL[13] = ((int) callResult_240[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_233; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3240); + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) -16L); + label_235: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_241 = (int) (memory.readInt((int) memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) < 0 ? memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) : memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) + 588)); + int ciFuncId_241 = instance.table(0).requiredRef(ciTableIdx_241); + com.dylibso.chicory.runtime.Instance ciRefInstance_241 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_241), instance); + if (!ciRefInstance_241.type(ciRefInstance_241.functionType(ciFuncId_241)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_241 = new long[4]; + callArgs_241[3] = ((long) (iL[13] & 255)); + callArgs_241[2] = ((long) iL[14]); + callArgs_241[1] = ((long) iL[0]); + callArgs_241[0] = ((long) iL[15]); + long[] callResult_241 = ciRefInstance_241.getMachine().call(ciFuncId_241, callArgs_241); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_241[0])) != 0) { + break label_235; + } + long[] callArgs_242 = new long[3]; + callArgs_242[2] = ((long) 0); + callArgs_242[1] = ((long) 20188); + callArgs_242[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_242); + { + _hs[0] = 1; + break _hb; + } + } + label_236: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3240); + if ((iL[13] & 1) != 0) { + break label_236; + } + label_237: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_243 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 592)); + int ciFuncId_243 = instance.table(0).requiredRef(ciTableIdx_243); + com.dylibso.chicory.runtime.Instance ciRefInstance_243 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_243), instance); + if (!ciRefInstance_243.type(ciRefInstance_243.functionType(ciFuncId_243)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_243 = new long[2]; + callArgs_243[1] = ((long) iL[0]); + callArgs_243[0] = ((long) iL[13]); + long[] callResult_243 = ciRefInstance_243.getMachine().call(ciFuncId_243, callArgs_243); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_243[0])) != 0) { + break label_237; + } + long[] callArgs_244 = new long[3]; + callArgs_244[2] = ((long) 0); + callArgs_244[1] = ((long) 20933); + callArgs_244[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_244); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_245 = new long[3]; + callArgs_245[2] = ((long) 12729); + callArgs_245[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)); + callArgs_245[0] = ((long) (iL[4] + 2936)); + long[] callResult_245 = instance.getMachine().call(804, callArgs_245); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_245[0])) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_246 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 596)); + int ciFuncId_246 = instance.table(0).requiredRef(ciTableIdx_246); + com.dylibso.chicory.runtime.Instance ciRefInstance_246 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_246), instance); + if (!ciRefInstance_246.type(ciRefInstance_246.functionType(ciFuncId_246)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_246 = new long[2]; + callArgs_246[1] = ((long) iL[0]); + callArgs_246[0] = ((long) iL[13]); + long[] callResult_246 = ciRefInstance_246.getMachine().call(ciFuncId_246, callArgs_246); + if (((int) callResult_246[0]) != 0) { + break label_232; + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3240); + } + label_238: { + if ((iL[13] & 3) != 0) { + break label_238; + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + break label_231; + } + label_239: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[13] & 4)) != 0) { + break label_239; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (int) 0); + label_240: { + label_241: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_247 = new long[3]; + callArgs_247[2] = ((long) (iL[4] + 3168)); + callArgs_247[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_247[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_247 = instance.getMachine().call(179, callArgs_247); + iL[13] = ((int) callResult_247[0]); + if (iL[13] != 0) { + break label_241; + } + iL[14] = 11290; + break label_240; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + lL[0] = (com.dylibso.chicory.runtime.OpcodeImpl.I64_EXTEND_I32_U(iL[13]) | -4294967296L); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) lL[0]); + iL[14] = 16308; + iL[13] = (iL[13] + 23); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[13], 7) != 0) { + break label_240; + } + if (((1 << iL[13]) & 197) != 0) { + break label_231; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2512, (int) 15888); + long[] callArgs_248 = new long[3]; + callArgs_248[2] = ((long) (iL[4] + 2512)); + callArgs_248[1] = ((long) iL[14]); + callArgs_248[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_248); + { + _hs[0] = 1; + break _hb; + } + } + label_242: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[14] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[14], memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)) != 0) { + break label_242; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2468, (int) 17653); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2464, (int) 7656); + long[] callArgs_249 = new long[3]; + callArgs_249[2] = ((long) (iL[4] + 2464)); + callArgs_249[1] = ((long) 10873); + callArgs_249[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_249); + { + _hs[0] = 1; + break _hb; + } + } + iL[13] = ((int) memory.read((int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[13]) < 0 ? (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[13]) : (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940) + iL[13]) + 0) & 0xFF); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[14]); + label_243: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[13], 5) != 0) { + break label_243; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2496, (int) iL[13]); + long[] callArgs_250 = new long[3]; + callArgs_250[2] = ((long) (iL[4] + 2496)); + callArgs_250[1] = ((long) 26383); + callArgs_250[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_250); + { + _hs[0] = 1; + break _hb; + } + } + lL[0] = -16L; + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_231; + } + long[] callArgs_251 = new long[2]; + callArgs_251[1] = ((long) (iL[4] + 3256)); + callArgs_251[0] = ((long) (iL[4] + 3168)); + instance.getMachine().call(38, callArgs_251); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2480, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 3179), 0) != 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168) : (iL[4] + 3168))); + long[] callArgs_252 = new long[3]; + callArgs_252[2] = ((long) (iL[4] + 2480)); + callArgs_252[1] = ((long) 30190); + callArgs_252[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_252); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 3179), -1) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_253 = new long[1]; + callArgs_253[0] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168)); + instance.getMachine().call(1777, callArgs_253); + { + _hs[0] = 1; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2400, (int) 1961); + long[] callArgs_254 = new long[3]; + callArgs_254[2] = ((long) (iL[4] + 2400)); + callArgs_254[1] = ((long) 11260); + callArgs_254[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_254); + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_255 = new long[3]; + callArgs_255[2] = ((long) 0); + callArgs_255[1] = ((long) 20974); + callArgs_255[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_255); + { + _hs[0] = 1; + break _hb; + } + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3248, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[14] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 600); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 2456, (long) lL[0]); + label_244: { + int ciTableIdx_256 = (int) (iL[14]); + int ciFuncId_256 = instance.table(0).requiredRef(ciTableIdx_256); + com.dylibso.chicory.runtime.Instance ciRefInstance_256 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_256), instance); + if (!ciRefInstance_256.type(ciRefInstance_256.functionType(ciFuncId_256)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_256 = new long[3]; + callArgs_256[2] = ((long) (iL[4] + 2456)); + callArgs_256[1] = ((long) iL[0]); + callArgs_256[0] = ((long) iL[13]); + long[] callResult_256 = ciRefInstance_256.getMachine().call(ciFuncId_256, callArgs_256); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_256[0])) != 0) { + break label_244; + } + long[] callArgs_257 = new long[3]; + callArgs_257[2] = ((long) 0); + callArgs_257[1] = ((long) 25214); + callArgs_257[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_257); + { + _hs[0] = 1; + break _hb; + } + } + label_245: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_258 = new long[3]; + callArgs_258[2] = ((long) (iL[4] + 3168)); + callArgs_258[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_258[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_258 = instance.getMachine().call(177, callArgs_258); + iL[13] = ((int) callResult_258[0]); + if (iL[13] != 0) { + break label_245; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2416, (int) 6457); + long[] callArgs_259 = new long[3]; + callArgs_259[2] = ((long) (iL[4] + 2416)); + callArgs_259[1] = ((long) 11260); + callArgs_259[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_259); + { + _hs[0] = 1; + break _hb; + } + } + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_246: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[13]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[15], iL[13]) != 0) { + break label_246; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2440, (int) iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2436, (int) iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2432, (int) 6457); + long[] callArgs_260 = new long[3]; + callArgs_260[2] = ((long) (iL[4] + 2432)); + callArgs_260[1] = ((long) 12552); + callArgs_260[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_260); + { + _hs[0] = 1; + break _hb; + } + } + label_247: { + label_248: { + label_249: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_261 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 604)); + int ciFuncId_261 = instance.table(0).requiredRef(ciTableIdx_261); + com.dylibso.chicory.runtime.Instance ciRefInstance_261 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_261), instance); + if (!ciRefInstance_261.type(ciRefInstance_261.functionType(ciFuncId_261)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_261 = new long[3]; + callArgs_261[2] = ((long) iL[15]); + callArgs_261[1] = ((long) iL[0]); + callArgs_261[0] = ((long) iL[13]); + long[] callResult_261 = ciRefInstance_261.getMachine().call(ciFuncId_261, callArgs_261); + if (((int) callResult_261[0]) != 0) { + break label_249; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[15]) != 0) { + break label_247; + } + iL[13] = 0; + break label_248; + } + long[] callArgs_262 = new long[3]; + callArgs_262[2] = ((long) 0); + callArgs_262[1] = ((long) 19558); + callArgs_262[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_262); + { + _hs[0] = 1; + break _hb; + } + } + label_250: while (true) { + label_251: { + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_263 = (int) (memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 608)); + int ciFuncId_263 = instance.table(0).requiredRef(ciTableIdx_263); + com.dylibso.chicory.runtime.Instance ciRefInstance_263 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_263), instance); + if (!ciRefInstance_263.type(ciRefInstance_263.functionType(ciFuncId_263)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_263 = new long[3]; + callArgs_263[2] = ((long) iL[13]); + callArgs_263[1] = ((long) iL[0]); + callArgs_263[0] = ((long) iL[14]); + long[] callResult_263 = ciRefInstance_263.getMachine().call(ciFuncId_263, callArgs_263); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_263[0])) != 0) { + break label_251; + } + long[] callArgs_264 = new long[3]; + callArgs_264[2] = ((long) 0); + callArgs_264[1] = ((long) 21849); + callArgs_264[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_264); + { + _hs[0] = 1; + break _hb; + } + } + label_252: { + label_253: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) iL[4] < 0 ? iL[4] : iL[4] + 3240) & 0xFF) & 4)) != 0) { + break label_253; + } + long[] callArgs_265 = new long[3]; + callArgs_265[2] = ((long) 12729); + callArgs_265[1] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936)); + callArgs_265[0] = ((long) (iL[4] + 2936)); + long[] callResult_265 = instance.getMachine().call(804, callArgs_265); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_265[0])) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + break label_252; + } + label_254: { + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_266 = new long[3]; + callArgs_266[2] = ((long) (iL[4] + 3168)); + callArgs_266[1] = ((long) (iL[14] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_266[0] = ((long) (iL[14] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_266 = instance.getMachine().call(177, callArgs_266); + iL[14] = ((int) callResult_266[0]); + if (iL[14] != 0) { + break label_254; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2448, (int) 2189); + long[] callArgs_267 = new long[3]; + callArgs_267[2] = ((long) (iL[4] + 2448)); + callArgs_267[1] = ((long) 11260); + callArgs_267[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_267); + { + _hs[0] = 1; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[14])); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + label_255: { + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_268 = (int) (memory.readInt((int) memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) < 0 ? memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) : memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) + 224)); + int ciFuncId_268 = instance.table(0).requiredRef(ciTableIdx_268); + com.dylibso.chicory.runtime.Instance ciRefInstance_268 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_268), instance); + if (!ciRefInstance_268.type(ciRefInstance_268.functionType(ciFuncId_268)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_268 = new long[2]; + callArgs_268[1] = ((long) 218); + callArgs_268[0] = ((long) iL[16]); + long[] callResult_268 = ciRefInstance_268.getMachine().call(ciFuncId_268, callArgs_268); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_268[0])) != 0) { + break label_255; + } + long[] callArgs_269 = new long[3]; + callArgs_269[2] = ((long) 0); + callArgs_269[1] = ((long) 25530); + callArgs_269[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_269); + { + _hs[0] = 1; + break _hb; + } + } + label_256: { + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_270 = (int) (memory.readInt((int) memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) < 0 ? memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) : memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) + 480)); + int ciFuncId_270 = instance.table(0).requiredRef(ciTableIdx_270); + com.dylibso.chicory.runtime.Instance ciRefInstance_270 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_270), instance); + if (!ciRefInstance_270.type(ciRefInstance_270.functionType(ciFuncId_270)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_270 = new long[2]; + callArgs_270[1] = ((long) iL[14]); + callArgs_270[0] = ((long) iL[16]); + long[] callResult_270 = ciRefInstance_270.getMachine().call(ciFuncId_270, callArgs_270); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_270[0])) != 0) { + break label_256; + } + long[] callArgs_271 = new long[3]; + callArgs_271[2] = ((long) 0); + callArgs_271[1] = ((long) 22865); + callArgs_271[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_271); + { + _hs[0] = 1; + break _hb; + } + } + label_257: { + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_272 = (int) (memory.readInt((int) memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) < 0 ? memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) : memory.readInt((int) iL[16] < 0 ? iL[16] : iL[16] + 0) + 232)); + int ciFuncId_272 = instance.table(0).requiredRef(ciTableIdx_272); + com.dylibso.chicory.runtime.Instance ciRefInstance_272 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_272), instance); + if (!ciRefInstance_272.type(ciRefInstance_272.functionType(ciFuncId_272)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_272 = new long[2]; + callArgs_272[1] = ((long) iL[14]); + callArgs_272[0] = ((long) iL[16]); + long[] callResult_272 = ciRefInstance_272.getMachine().call(ciFuncId_272, callArgs_272); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_272[0])) != 0) { + break label_257; + } + long[] callArgs_273 = new long[3]; + callArgs_273[2] = ((long) 0); + callArgs_273[1] = ((long) 25792); + callArgs_273[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_273); + { + _hs[0] = 1; + break _hb; + } + } + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_274 = (int) (memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 368)); + int ciFuncId_274 = instance.table(0).requiredRef(ciTableIdx_274); + com.dylibso.chicory.runtime.Instance ciRefInstance_274 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_274), instance); + if (!ciRefInstance_274.type(ciRefInstance_274.functionType(ciFuncId_274)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_274 = new long[1]; + callArgs_274[0] = ((long) iL[14]); + long[] callResult_274 = ciRefInstance_274.getMachine().call(ciFuncId_274, callArgs_274); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_274[0])) != 0) { + break label_252; + } + long[] callArgs_275 = new long[3]; + callArgs_275[2] = ((long) 0); + callArgs_275[1] = ((long) 22779); + callArgs_275[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_275); + { + _hs[0] = 1; + break _hb; + } + } + label_258: { + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_276 = (int) (memory.readInt((int) memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) < 0 ? memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) : memory.readInt((int) iL[14] < 0 ? iL[14] : iL[14] + 0) + 612)); + int ciFuncId_276 = instance.table(0).requiredRef(ciTableIdx_276); + com.dylibso.chicory.runtime.Instance ciRefInstance_276 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_276), instance); + if (!ciRefInstance_276.type(ciRefInstance_276.functionType(ciFuncId_276)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_276 = new long[3]; + callArgs_276[2] = ((long) iL[13]); + callArgs_276[1] = ((long) iL[0]); + callArgs_276[0] = ((long) iL[14]); + long[] callResult_276 = ciRefInstance_276.getMachine().call(ciFuncId_276, callArgs_276); + if (((int) callResult_276[0]) != 0) { + break label_258; + } + iL[13] = (iL[13] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[13], iL[15]) != 0) { + break label_247; + } + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_250; + } + break; + } + long[] callArgs_277 = new long[3]; + callArgs_277[2] = ((long) 0); + callArgs_277[1] = ((long) 21879); + callArgs_277[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_277); + { + _hs[0] = 1; + break _hb; + } + } + label_259: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_278 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 616)); + int ciFuncId_278 = instance.table(0).requiredRef(ciTableIdx_278); + com.dylibso.chicory.runtime.Instance ciRefInstance_278 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_278), instance); + if (!ciRefInstance_278.type(ciRefInstance_278.functionType(ciFuncId_278)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_278 = new long[2]; + callArgs_278[1] = ((long) iL[0]); + callArgs_278[0] = ((long) iL[13]); + long[] callResult_278 = ciRefInstance_278.getMachine().call(ciFuncId_278, callArgs_278); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_278[0])) != 0) { + break label_259; + } + long[] callArgs_279 = new long[3]; + callArgs_279[2] = ((long) 0); + callArgs_279[1] = ((long) 20221); + callArgs_279[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_279); + { + _hs[0] = 1; + break _hb; + } + } + iL[0] = (iL[0] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[3], iL[0]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_228; + } + break; + } + } while (false); + return _hs[0]; + } + + private static int func_801__h21(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_367: { + label_368: { + label_369: { + label_370: { + label_371: { + label_372: { + label_373: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) + 13) & 0xFF)) != 0) { + break label_373; + } + long[] callArgs_402 = new long[3]; + callArgs_402[2] = ((long) 13005); + callArgs_402[1] = ((long) (iL[4] + 3256)); + callArgs_402[0] = ((long) (iL[4] + 2936)); + long[] callResult_402 = instance.getMachine().call(805, callArgs_402); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_402[0])) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3256); + switch((iL[3] + 34)) { + case 0: + { + break label_369; + } + case 1: + { + break label_370; + } + case 2: + { + break label_372; + } + default: + { + break label_368; + } + } + } + label_374: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[13] = (iL[15] + 1); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[13], iL[14]) != 0) { + break label_374; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1652, (int) 13005); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1648, (int) 7656); + long[] callArgs_403 = new long[3]; + callArgs_403[2] = ((long) (iL[4] + 1648)); + callArgs_403[1] = ((long) 10873); + callArgs_403[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_403); + { + _hs[0] = 10001; + break _hb; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + iL[15] = ((int) memory.read((int) (iL[3] + iL[15]) < 0 ? (iL[3] + iL[15]) : (iL[3] + iL[15]) + 0) & 0xFF); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_375: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(96, iL[15]) != 0) { + break label_375; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1760, (int) iL[15]); + long[] callArgs_404 = new long[3]; + callArgs_404[2] = ((long) (iL[4] + 1760)); + callArgs_404[1] = ((long) 29616); + callArgs_404[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_404); + { + _hs[0] = 10001; + break _hb; + } + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) -32L); + break label_371; + } + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + } + label_376: { + long[] callArgs_405 = new long[3]; + callArgs_405[2] = ((long) (iL[4] + 3168)); + callArgs_405[1] = ((long) (iL[3] + iL[14])); + callArgs_405[0] = ((long) (iL[3] + iL[13])); + long[] callResult_405 = instance.getMachine().call(177, callArgs_405); + iL[3] = ((int) callResult_405[0]); + if (iL[3] != 0) { + break label_376; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1664, (int) 6468); + long[] callArgs_406 = new long[3]; + callArgs_406[2] = ((long) (iL[4] + 1664)); + callArgs_406[1] = ((long) 11260); + callArgs_406[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_406); + { + _hs[0] = 10001; + break _hb; + } + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_377: { + iL[16] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[13] = (iL[14] - iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[16], iL[13]) != 0) { + break label_377; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1688, (int) iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1684, (int) iL[16]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1680, (int) 6468); + long[] callArgs_407 = new long[3]; + callArgs_407[2] = ((long) (iL[4] + 1680)); + callArgs_407[1] = ((long) 12552); + callArgs_407[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_407); + { + _hs[0] = 10001; + break _hb; + } + } + label_378: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2976); + iL[13] = ((memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2980) - iL[15]) >> 3); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[16], iL[13]) != 0) { + break label_378; + } + long[] callArgs_408 = new long[2]; + callArgs_408[1] = ((long) (iL[16] - iL[13])); + callArgs_408[0] = ((long) iL[8]); + instance.getMachine().call(248, callArgs_408); + break label_367; + } + label_379: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[16], iL[13]) != 0) { + break label_379; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2980, (int) (iL[15] + (iL[16] << 3))); + } + if (iL[16] != 0) { + break label_367; + } + iL[19] = 1; + break _hb; + } + label_380: { + if (((int) memory.read((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) + 13) & 0xFF) != 0) { + break label_380; + } + long[] callArgs_409 = new long[3]; + callArgs_409[2] = ((long) 0); + callArgs_409[1] = ((long) 18034); + callArgs_409[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_409); + { + _hs[0] = 10001; + break _hb; + } + } + label_381: { + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_410 = new long[3]; + callArgs_410[2] = ((long) (iL[4] + 3168)); + callArgs_410[1] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_410[0] = ((long) (iL[3] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_410 = instance.getMachine().call(177, callArgs_410); + iL[3] = ((int) callResult_410[0]); + if (iL[3] != 0) { + break label_381; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1792, (int) 6666); + long[] callArgs_411 = new long[3]; + callArgs_411[2] = ((long) (iL[4] + 1792)); + callArgs_411[1] = ((long) 11260); + callArgs_411[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_411); + { + _hs[0] = 10001; + break _hb; + } + } + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[3]); + label_382: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[3] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[3]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[13], iL[3]) != 0) { + break label_382; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1816, (int) iL[3]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1812, (int) iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1808, (int) 6666); + long[] callArgs_412 = new long[3]; + callArgs_412[2] = ((long) (iL[4] + 1808)); + callArgs_412[1] = ((long) 12552); + callArgs_412[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_412); + { + _hs[0] = 10001; + break _hb; + } + } + label_383: { + label_384: { + label_385: { + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3004); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3000); + iL[15] = com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((iL[14] - iL[3]), 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[13], iL[15]) != 0) { + break label_385; + } + long[] callArgs_413 = new long[2]; + callArgs_413[1] = ((long) (iL[13] - iL[15])); + callArgs_413[0] = ((long) iL[10]); + instance.getMachine().call(809, callArgs_413); + iL[3] = 0; + break label_384; + } + label_386: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GE_U(iL[13], iL[15]) != 0) { + break label_386; + } + iL[14] = (iL[3] + (iL[13] * 12)); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 3004, (int) iL[14]); + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + break label_383; + } + iL[3] = 0; + } + label_387: while (true) { + long[] callArgs_414 = new long[2]; + callArgs_414[1] = ((long) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3000) + iL[3])); + callArgs_414[0] = ((long) (iL[4] + 2936)); + long[] callResult_414 = instance.getMachine().call(810, callArgs_414); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_414[0])) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + iL[3] = (iL[3] + 12); + iL[13] = (iL[13] + -1); + if (iL[13] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_387; + } + break; + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3000); + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3004); + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_415 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 48)); + int ciFuncId_415 = instance.table(0).requiredRef(ciTableIdx_415); + com.dylibso.chicory.runtime.Instance ciRefInstance_415 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_415), instance); + if (!ciRefInstance_415.type(ciRefInstance_415.functionType(ciFuncId_415)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_415 = new long[4]; + callArgs_415[3] = ((long) iL[3]); + callArgs_415[2] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((iL[14] - iL[3]), 12)); + callArgs_415[1] = ((long) iL[17]); + callArgs_415[0] = ((long) iL[13]); + long[] callResult_415 = ciRefInstance_415.getMachine().call(ciFuncId_415, callArgs_415); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_415[0])) != 0) { + { + _hs[0] = 10000; + break _hb; + } + } + long[] callArgs_416 = new long[3]; + callArgs_416[2] = ((long) 0); + callArgs_416[1] = ((long) 25185); + callArgs_416[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_416); + { + _hs[0] = 10001; + break _hb; + } + } + label_388: { + if (((int) memory.read((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036) + 13) & 0xFF) != 0) { + break label_388; + } + long[] callArgs_417 = new long[3]; + callArgs_417[2] = ((long) 0); + callArgs_417[1] = ((long) 17997); + callArgs_417[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_417); + { + _hs[0] = 10001; + break _hb; + } + } + long[] callArgs_418 = new long[2]; + callArgs_418[1] = ((long) (iL[4] + 3168)); + callArgs_418[0] = ((long) (iL[4] + 2936)); + long[] callResult_418 = instance.getMachine().call(810, callArgs_418); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_418[0])) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[13] = memory.readInt((int) memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) < 0 ? memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) : memory.readInt((int) iL[3] < 0 ? iL[3] : iL[3] + 0) + 52); + memory.writeI32((int) ((iL[4] + 1824) + 8) < 0 ? ((iL[4] + 1824) + 8) : ((iL[4] + 1824) + 8) + 0, (int) memory.readInt((int) ((iL[4] + 3168) + 8) < 0 ? ((iL[4] + 3168) + 8) : ((iL[4] + 3168) + 8) + 0)); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 1824, (long) memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168)); + int ciTableIdx_419 = (int) (iL[13]); + int ciFuncId_419 = instance.table(0).requiredRef(ciTableIdx_419); + com.dylibso.chicory.runtime.Instance ciRefInstance_419 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_419), instance); + if (!ciRefInstance_419.type(ciRefInstance_419.functionType(ciFuncId_419)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_419 = new long[3]; + callArgs_419[2] = ((long) (iL[4] + 1824)); + callArgs_419[1] = ((long) iL[17]); + callArgs_419[0] = ((long) iL[3]); + long[] callResult_419 = ciRefInstance_419.getMachine().call(ciFuncId_419, callArgs_419); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_419[0])) != 0) { + { + _hs[0] = 10000; + break _hb; + } + } + long[] callArgs_420 = new long[3]; + callArgs_420[2] = ((long) 0); + callArgs_420[1] = ((long) 25157); + callArgs_420[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_420); + { + _hs[0] = 10001; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1776, (int) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S(iL[3], 0) != 0 ? 29327 : 38861)); + iL[0] = (iL[3] >> 31); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 1780, (int) ((iL[3] ^ iL[0]) - iL[0])); + long[] callArgs_421 = new long[3]; + callArgs_421[2] = ((long) (iL[4] + 1776)); + callArgs_421[1] = ((long) 29422); + callArgs_421[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_421); + { + _hs[0] = 10001; + break _hb; + } + } + iL[3] = 0; + iL[13] = iL[16]; + label_389: while (true) { + long[] callArgs_422 = new long[3]; + callArgs_422[2] = ((long) 15904); + callArgs_422[1] = ((long) (iL[4] + 3168)); + callArgs_422[0] = ((long) (iL[4] + 2936)); + long[] callResult_422 = instance.getMachine().call(805, callArgs_422); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_422[0])) != 0) { + { + _hs[0] = 10001; + break _hb; + } + } + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3036); + label_390: { + label_391: { + label_392: { + label_393: { + label_394: { + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[15] = (int) lL[0]; + switch((iL[15] + 23)) { + case 0: + { + break label_394; + } + case 1: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 2: + { + break label_393; + } + case 3: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 4: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 5: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 6: + { + break label_391; + } + case 7: + { + break label_391; + } + case 8: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 9: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 10: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 11: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 12: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 13: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 14: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 15: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 16: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 17: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 18: + { + break label_392; + } + case 19: + { + break label_390; + } + case 20: + { + break label_390; + } + case 21: + { + break label_390; + } + case 22: + { + break label_390; + } + default: + { + { + _hs[0] = 10002; + break _hb; + } + } + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[14] < 0 ? iL[14] : iL[14] + 0) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + break label_390; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[14] < 0 ? iL[14] : iL[14] + 6) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + break label_390; + } + if (((int) memory.read((int) iL[14] < 0 ? iL[14] : iL[14] + 4) & 0xFF) != 0) { + break label_390; + } + { + _hs[0] = 10002; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) iL[14] < 0 ? iL[14] : iL[14] + 10) & 0xFF)) != 0) { + { + _hs[0] = 10002; + break _hb; + } + } + } + memory.writeLong((int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2976) + iL[3]) < 0 ? (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2976) + iL[3]) : (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2976) + iL[3]) + 0, (long) lL[0]); + iL[3] = (iL[3] + 8); + iL[13] = (iL[13] + -1); + if (iL[13] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_389; + } + break; + } + iL[19] = 0; + iL[14] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936); + iL[3] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948); + } while (false); + return _hs[0]; + } + + private static int func_801__h22(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_79: { + label_80: { + label_81: { + switch(iL[15]) { + case 0: + { + break label_81; + } + case 1: + { + break label_80; + } + case 2: + { + break label_79; + } + case 3: + { + { + _hs[0] = 1; + break _hb; + } + } + case 4: + { + break _hb; + } + case 5: + { + break _hb; + } + case 6: + { + break _hb; + } + case 7: + { + break _hb; + } + case 8: + { + break _hb; + } + case 9: + { + break _hb; + } + case 10: + { + { + _hs[0] = 1; + break _hb; + } + } + case 11: + { + break _hb; + } + default: + { + { + _hs[0] = 1; + break _hb; + } + } + } + } + label_82: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_42 = (int) (memory.readInt((int) memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) < 0 ? memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) : memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) + 672)); + int ciFuncId_42 = instance.table(0).requiredRef(ciTableIdx_42); + com.dylibso.chicory.runtime.Instance ciRefInstance_42 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_42), instance); + if (!ciRefInstance_42.type(ciRefInstance_42.functionType(ciFuncId_42)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_42 = new long[4]; + callArgs_42[3] = ((long) iL[13]); + callArgs_42[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3216)); + callArgs_42[1] = ((long) iL[16]); + callArgs_42[0] = ((long) iL[15]); + long[] callResult_42 = ciRefInstance_42.getMachine().call(ciFuncId_42, callArgs_42); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_42[0])) != 0) { + break label_82; + } + long[] callArgs_43 = new long[3]; + callArgs_43[2] = ((long) 0); + callArgs_43[1] = ((long) 23156); + callArgs_43[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_43); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + long[] callArgs_44 = new long[3]; + callArgs_44[2] = ((long) 16938); + callArgs_44[1] = ((long) (iL[4] + 3168)); + callArgs_44[0] = ((long) (iL[4] + 2936)); + long[] callResult_44 = instance.getMachine().call(803, callArgs_44); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_44[0])) != 0) { + { + _hs[0] = 50003; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3256, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[15] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 676); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 168, (long) lL[0]); + int ciTableIdx_45 = (int) (iL[15]); + int ciFuncId_45 = instance.table(0).requiredRef(ciTableIdx_45); + com.dylibso.chicory.runtime.Instance ciRefInstance_45 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_45), instance); + if (!ciRefInstance_45.type(ciRefInstance_45.functionType(ciFuncId_45)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_45 = new long[2]; + callArgs_45[1] = ((long) (iL[4] + 168)); + callArgs_45[0] = ((long) iL[13]); + long[] callResult_45 = ciRefInstance_45.getMachine().call(ciFuncId_45, callArgs_45); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_45[0])) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + long[] callArgs_46 = new long[3]; + callArgs_46[2] = ((long) 0); + callArgs_46[1] = ((long) 25393); + callArgs_46[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_46); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + label_83: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_47 = (int) (memory.readInt((int) memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) < 0 ? memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) : memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) + 680)); + int ciFuncId_47 = instance.table(0).requiredRef(ciTableIdx_47); + com.dylibso.chicory.runtime.Instance ciRefInstance_47 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_47), instance); + if (!ciRefInstance_47.type(ciRefInstance_47.functionType(ciFuncId_47)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_47 = new long[4]; + callArgs_47[3] = ((long) iL[13]); + callArgs_47[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3216)); + callArgs_47[1] = ((long) iL[16]); + callArgs_47[0] = ((long) iL[15]); + long[] callResult_47 = ciRefInstance_47.getMachine().call(ciFuncId_47, callArgs_47); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_47[0])) != 0) { + break label_83; + } + long[] callArgs_48 = new long[3]; + callArgs_48[2] = ((long) 0); + callArgs_48[1] = ((long) 23044); + callArgs_48[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_48); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + label_84: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_49 = new long[3]; + callArgs_49[2] = ((long) (iL[4] + 3168)); + callArgs_49[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_49[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_49 = instance.getMachine().call(177, callArgs_49); + iL[13] = ((int) callResult_49[0]); + if (iL[13] != 0) { + break label_84; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 176, (int) 6595); + long[] callArgs_50 = new long[3]; + callArgs_50[2] = ((long) (iL[4] + 176)); + callArgs_50[1] = ((long) 11260); + callArgs_50[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_50); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_85: { + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[13]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[17], iL[13]) != 0) { + break label_85; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 200, (int) iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 196, (int) iL[17]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 192, (int) 6595); + long[] callArgs_51 = new long[3]; + callArgs_51[2] = ((long) (iL[4] + 192)); + callArgs_51[1] = ((long) 12552); + callArgs_51[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_51); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_52 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 684)); + int ciFuncId_52 = instance.table(0).requiredRef(ciTableIdx_52); + com.dylibso.chicory.runtime.Instance ciRefInstance_52 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_52), instance); + if (!ciRefInstance_52.type(ciRefInstance_52.functionType(ciFuncId_52)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_52 = new long[2]; + callArgs_52[1] = ((long) iL[17]); + callArgs_52[0] = ((long) iL[13]); + long[] callResult_52 = ciRefInstance_52.getMachine().call(ciFuncId_52, callArgs_52); + if (((int) callResult_52[0]) != 0) { + { + _hs[0] = 20002; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[17]) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + iL[15] = -1; + label_86: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + label_87: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_53 = new long[3]; + callArgs_53[2] = ((long) (iL[4] + 3224)); + callArgs_53[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_53[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_53 = instance.getMachine().call(177, callArgs_53); + iL[13] = ((int) callResult_53[0]); + if (iL[13] != 0) { + break label_87; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 208, (int) 1564); + long[] callArgs_54 = new long[3]; + callArgs_54[2] = ((long) (iL[4] + 208)); + callArgs_54[1] = ((long) 11260); + callArgs_54[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_54); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13])); + label_88: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3224); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[15], iL[13]) != 0) { + break label_88; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 224, (int) iL[15]); + long[] callArgs_55 = new long[3]; + callArgs_55[2] = ((long) (iL[4] + 224)); + callArgs_55[1] = ((long) 5621); + callArgs_55[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_55); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + label_89: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[15]) != 0) { + break label_89; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[13], iL[15]) != 0) { + break label_89; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 256, (int) iL[13]); + long[] callArgs_56 = new long[3]; + callArgs_56[2] = ((long) (iL[4] + 256)); + callArgs_56[1] = ((long) 5523); + callArgs_56[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_56); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + label_90: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[13], (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3068) + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3048))) != 0) { + break label_90; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 240, (int) iL[13]); + long[] callArgs_57 = new long[3]; + callArgs_57[2] = ((long) (iL[4] + 240)); + callArgs_57[1] = ((long) 5354); + callArgs_57[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_57); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + long[] callArgs_58 = new long[3]; + callArgs_58[2] = ((long) 16834); + callArgs_58[1] = ((long) (iL[4] + 3168)); + callArgs_58[0] = ((long) (iL[4] + 2936)); + long[] callResult_58 = instance.getMachine().call(803, callArgs_58); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_58[0])) != 0) { + { + _hs[0] = 50003; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3248, (long) lL[0]); + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[18] = memory.readInt((int) memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) < 0 ? memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) : memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) + 688); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 232, (long) lL[0]); + label_91: { + int ciTableIdx_59 = (int) (iL[18]); + int ciFuncId_59 = instance.table(0).requiredRef(ciTableIdx_59); + com.dylibso.chicory.runtime.Instance ciRefInstance_59 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_59), instance); + if (!ciRefInstance_59.type(ciRefInstance_59.functionType(ciFuncId_59)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_59 = new long[3]; + callArgs_59[2] = ((long) (iL[4] + 232)); + callArgs_59[1] = ((long) iL[13]); + callArgs_59[0] = ((long) iL[15]); + long[] callResult_59 = ciRefInstance_59.getMachine().call(ciFuncId_59, callArgs_59); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_59[0])) != 0) { + break label_91; + } + long[] callArgs_60 = new long[3]; + callArgs_60[2] = ((long) 0); + callArgs_60[1] = ((long) 25334); + callArgs_60[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_60); + { + _hs[0] = 50003; + break _hb; + } + } + iL[15] = iL[13]; + iL[17] = (iL[17] + -1); + if (iL[17] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_86; + } + { + _hs[0] = 2; + break _hb; + } + } + } + label_92: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_61 = (int) (memory.readInt((int) memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) < 0 ? memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) : memory.readInt((int) iL[15] < 0 ? iL[15] : iL[15] + 0) + 692)); + int ciFuncId_61 = instance.table(0).requiredRef(ciTableIdx_61); + com.dylibso.chicory.runtime.Instance ciRefInstance_61 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_61), instance); + if (!ciRefInstance_61.type(ciRefInstance_61.functionType(ciFuncId_61)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_61 = new long[4]; + callArgs_61[3] = ((long) iL[13]); + callArgs_61[2] = ((long) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3216)); + callArgs_61[1] = ((long) iL[16]); + callArgs_61[0] = ((long) iL[15]); + long[] callResult_61 = ciRefInstance_61.getMachine().call(ciFuncId_61, callArgs_61); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_61[0])) != 0) { + break label_92; + } + long[] callArgs_62 = new long[3]; + callArgs_62[2] = ((long) 0); + callArgs_62[1] = ((long) 23118); + callArgs_62[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_62); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[13]) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + label_93: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_63 = new long[3]; + callArgs_63[2] = ((long) (iL[4] + 3168)); + callArgs_63[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_63[0] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_63 = instance.getMachine().call(177, callArgs_63); + iL[13] = ((int) callResult_63[0]); + if (iL[13] != 0) { + break label_93; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 272, (int) 6356); + long[] callArgs_64 = new long[3]; + callArgs_64[2] = ((long) (iL[4] + 272)); + callArgs_64[1] = ((long) 11260); + callArgs_64[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_64); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_94: { + iL[21] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[13]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[21], iL[13]) != 0) { + break label_94; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 296, (int) iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 292, (int) iL[21]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 288, (int) 6356); + long[] callArgs_65 = new long[3]; + callArgs_65[2] = ((long) (iL[4] + 288)); + callArgs_65[1] = ((long) 12552); + callArgs_65[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_65); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_66 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 696)); + int ciFuncId_66 = instance.table(0).requiredRef(ciTableIdx_66); + com.dylibso.chicory.runtime.Instance ciRefInstance_66 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_66), instance); + if (!ciRefInstance_66.type(ciRefInstance_66.functionType(ciFuncId_66)).typesMatch(instance.type(5))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_66 = new long[2]; + callArgs_66[1] = ((long) iL[21]); + callArgs_66[0] = ((long) iL[13]); + long[] callResult_66 = ciRefInstance_66.getMachine().call(ciFuncId_66, callArgs_66); + if (((int) callResult_66[0]) != 0) { + { + _hs[0] = 20003; + break _hb; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[21]) != 0) { + { + _hs[0] = 2; + break _hb; + } + } + iL[22] = 0; + iL[13] = -1; + label_95: while (true) { + label_96: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_67 = new long[3]; + callArgs_67[2] = ((long) (iL[4] + 3168)); + callArgs_67[1] = ((long) (iL[15] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_67[0] = ((long) (iL[15] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_67 = instance.getMachine().call(177, callArgs_67); + iL[15] = ((int) callResult_67[0]); + if (iL[15] != 0) { + break label_96; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 304, (int) 1564); + long[] callArgs_68 = new long[3]; + callArgs_68[2] = ((long) (iL[4] + 304)); + callArgs_68[1] = ((long) 11260); + callArgs_68[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_68); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + iL[15] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[15]); + label_97: { + iL[18] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[18], (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3068) + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3048))) != 0) { + break label_97; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 416, (int) iL[18]); + long[] callArgs_69 = new long[3]; + callArgs_69[2] = ((long) (iL[4] + 416)); + callArgs_69[1] = ((long) 5354); + callArgs_69[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_69); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + label_98: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[13]) != 0) { + break label_98; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[18], iL[13]) != 0) { + break label_98; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 400, (int) iL[18]); + long[] callArgs_70 = new long[3]; + callArgs_70[2] = ((long) (iL[4] + 400)); + callArgs_70[1] = ((long) 5516); + callArgs_70[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_70); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + label_99: { + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_71 = new long[3]; + callArgs_71[2] = ((long) (iL[4] + 3168)); + callArgs_71[1] = ((long) (iL[13] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_71[0] = ((long) (iL[13] + iL[15])); + long[] callResult_71 = instance.getMachine().call(177, callArgs_71); + iL[13] = ((int) callResult_71[0]); + if (iL[13] != 0) { + break label_99; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 320, (int) 6506); + long[] callArgs_72 = new long[3]; + callArgs_72[2] = ((long) (iL[4] + 320)); + callArgs_72[1] = ((long) 11260); + callArgs_72[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_72); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) iL[13]); + label_100: { + iL[17] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + iL[13] = (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936) - iL[13]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_U(iL[17], iL[13]) != 0) { + break label_100; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 344, (int) iL[13]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 340, (int) iL[17]); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 336, (int) 6506); + long[] callArgs_73 = new long[3]; + callArgs_73[2] = ((long) (iL[4] + 336)); + callArgs_73[1] = ((long) 12552); + callArgs_73[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_73); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + int ciTableIdx_74 = (int) (memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 700)); + int ciFuncId_74 = instance.table(0).requiredRef(ciTableIdx_74); + com.dylibso.chicory.runtime.Instance ciRefInstance_74 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_74), instance); + if (!ciRefInstance_74.type(ciRefInstance_74.functionType(ciFuncId_74)).typesMatch(instance.type(6))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_74 = new long[3]; + callArgs_74[2] = ((long) iL[17]); + callArgs_74[1] = ((long) iL[18]); + callArgs_74[0] = ((long) iL[13]); + long[] callResult_74 = ciRefInstance_74.getMachine().call(ciFuncId_74, callArgs_74); + if (((int) callResult_74[0]) != 0) { + { + _hs[0] = 20000; + break _hb; + } + } + label_101: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[17]) != 0) { + break label_101; + } + iL[13] = -1; + label_102: while (true) { + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168, (long) 0L); + label_103: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2940); + long[] callArgs_75 = new long[3]; + callArgs_75[2] = ((long) (iL[4] + 3224)); + callArgs_75[1] = ((long) (iL[15] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2936))); + callArgs_75[0] = ((long) (iL[15] + memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948))); + long[] callResult_75 = instance.getMachine().call(177, callArgs_75); + iL[15] = ((int) callResult_75[0]); + if (iL[15] != 0) { + break label_103; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 352, (int) 2130); + long[] callArgs_76 = new long[3]; + callArgs_76[2] = ((long) (iL[4] + 352)); + callArgs_76[1] = ((long) 11260); + callArgs_76[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_76); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2948, (int) (memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2948) + iL[15])); + label_104: { + iL[15] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 3224); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[13], iL[15]) != 0) { + break label_104; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 368, (int) iL[13]); + long[] callArgs_77 = new long[3]; + callArgs_77[2] = ((long) (iL[4] + 368)); + callArgs_77[1] = ((long) 5381); + callArgs_77[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_77); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + label_105: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(-1, iL[13]) != 0) { + break label_105; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[15], iL[13]) != 0) { + break label_105; + } + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 384, (int) iL[15]); + long[] callArgs_78 = new long[3]; + callArgs_78[2] = ((long) (iL[4] + 384)); + callArgs_78[1] = ((long) 5555); + callArgs_78[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_78); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + long[] callArgs_79 = new long[3]; + callArgs_79[2] = ((long) 16984); + callArgs_79[1] = ((long) (iL[4] + 3168)); + callArgs_79[0] = ((long) (iL[4] + 2936)); + long[] callResult_79 = instance.getMachine().call(803, callArgs_79); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(1, ((int) callResult_79[0])) != 0) { + { + _hs[0] = 50003; + break _hb; + } + } + lL[0] = memory.readLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3168); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 3240, (long) lL[0]); + iL[13] = memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 2972); + iL[19] = memory.readInt((int) memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) < 0 ? memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) : memory.readInt((int) iL[13] < 0 ? iL[13] : iL[13] + 0) + 704); + memory.writeLong((int) iL[4] < 0 ? iL[4] : iL[4] + 376, (long) lL[0]); + label_106: { + int ciTableIdx_80 = (int) (iL[19]); + int ciFuncId_80 = instance.table(0).requiredRef(ciTableIdx_80); + com.dylibso.chicory.runtime.Instance ciRefInstance_80 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_80), instance); + if (!ciRefInstance_80.type(ciRefInstance_80.functionType(ciFuncId_80)).typesMatch(instance.type(4))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_80 = new long[4]; + callArgs_80[3] = ((long) (iL[4] + 376)); + callArgs_80[2] = ((long) iL[15]); + callArgs_80[1] = ((long) iL[18]); + callArgs_80[0] = ((long) iL[13]); + long[] callResult_80 = ciRefInstance_80.getMachine().call(ciFuncId_80, callArgs_80); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_80[0])) != 0) { + break label_106; + } + long[] callArgs_81 = new long[3]; + callArgs_81[2] = ((long) 0); + callArgs_81[1] = ((long) 25365); + callArgs_81[0] = ((long) (iL[4] + 2936)); + instance.getMachine().call(802, callArgs_81); + memory.writeI32((int) iL[4] < 0 ? iL[4] : iL[4] + 2936, (int) iL[0]); + { + _hs[0] = 50002; + break _hb; + } + } + iL[13] = iL[15]; + iL[17] = (iL[17] + -1); + if (iL[17] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_102; + } + break; + } + } + iL[13] = iL[18]; + iL[22] = (iL[22] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[21], iL[22]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_95; + } + { + _hs[0] = 2; + break _hb; + } + } + } while (false); + return _hs[0]; + } + + private static int func_804__h16(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + label_136: { + int _d17 = func_804__h17(iL, lL, memory, instance); + if (_d17 >= 10000) { + _hs[0] = (_d17 - 10000); + break _hb; + } + } + label_137: { + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_7 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 544)); + int ciFuncId_7 = instance.table(0).requiredRef(ciTableIdx_7); + com.dylibso.chicory.runtime.Instance ciRefInstance_7 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_7), instance); + if (!ciRefInstance_7.type(ciRefInstance_7.functionType(ciFuncId_7)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_7 = new long[1]; + callArgs_7[0] = ((long) iL[4]); + long[] callResult_7 = ciRefInstance_7.getMachine().call(ciFuncId_7, callArgs_7); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_7[0])) != 0) { + break label_137; + } + long[] callArgs_8 = new long[3]; + callArgs_8[2] = ((long) 0); + callArgs_8[1] = ((long) 22619); + callArgs_8[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_8); + iL[11] = 1; + { + _hs[0] = 50007; + break _hb; + } + } + iL[4] = memory.readInt((int) iL[8] < 0 ? iL[8] : iL[8] + 0); + int ciTableIdx_9 = (int) (memory.readInt((int) memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) < 0 ? memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) : memory.readInt((int) iL[4] < 0 ? iL[4] : iL[4] + 0) + 228)); + int ciFuncId_9 = instance.table(0).requiredRef(ciTableIdx_9); + com.dylibso.chicory.runtime.Instance ciRefInstance_9 = java.util.Objects.requireNonNullElse(instance.table(0).instance(ciTableIdx_9), instance); + if (!ciRefInstance_9.type(ciRefInstance_9.functionType(ciFuncId_9)).typesMatch(instance.type(1))) { + throw new com.dylibso.chicory.wasm.ChicoryException("indirect call type mismatch"); + } + long[] callArgs_9 = new long[1]; + callArgs_9[0] = ((long) iL[4]); + long[] callResult_9 = ciRefInstance_9.getMachine().call(ciFuncId_9, callArgs_9); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) callResult_9[0])) != 0) { + { + _hs[0] = 50008; + break _hb; + } + } + long[] callArgs_10 = new long[3]; + callArgs_10[2] = ((long) 0); + callArgs_10[1] = ((long) 25128); + callArgs_10[0] = ((long) iL[0]); + instance.getMachine().call(802, callArgs_10); + iL[11] = 1; + { + _hs[0] = 50007; + break _hb; + } + } while (false); + return _hs[0]; + } + + private static int func_41__h7(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[37] = memory.readInt((int) (iL[0] + 148) < 0 ? (iL[0] + 148) : (iL[0] + 148) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[37]) != 0) { + break _hb; + } + iL[38] = (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + -1); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) iL[38]); + label_184: { + iL[24] = memory.readInt((int) (iL[0] + 72) < 0 ? (iL[0] + 72) : (iL[0] + 72) + 0); + iL[36] = memory.readInt((int) (iL[0] + 76) < 0 ? (iL[0] + 76) : (iL[0] + 76) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_184; + } + iL[30] = (iL[38] + iL[37]); + label_185: while (true) { + label_186: { + iL[37] = (iL[24] + 4); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[38], memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0)) != 0) { + break label_186; + } + memory.writeI32((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (int) iL[30]); + } + iL[24] = (iL[24] + 20); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_185; + } + break; + } + } + long[] callArgs_182 = new long[2]; + callArgs_182[1] = ((long) 0); + callArgs_182[0] = ((long) (iL[23] + 560)); + long[] callResult_182 = instance.getMachine().call(229, callArgs_182); + iL[27] = ((int) callResult_182[0]); + iL[26] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) iL[27]); + label_187: { + iL[31] = memory.readInt((int) (iL[0] + 144) < 0 ? (iL[0] + 144) : (iL[0] + 144) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[31]) != 0) { + break label_187; + } + lL[0] = memory.readLong((int) 0 < 0 ? 0 : 0 + 29088); + lL[1] = memory.readLong((int) 0 < 0 ? 0 : 0 + 29082); + label_188: while (true) { + long[] callArgs_183 = new long[1]; + callArgs_183[0] = ((long) 16); + long[] callResult_183 = instance.getMachine().call(1776, callArgs_183); + iL[24] = ((int) callResult_183[0]); + memory.writeByte((int) iL[24] < 0 ? iL[24] : iL[24] + 14, (byte) (0)); + memory.writeLong((int) (iL[24] + 6) < 0 ? (iL[24] + 6) : (iL[24] + 6) + 0, (long) lL[0]); + memory.writeLong((int) iL[24] < 0 ? iL[24] : iL[24] + 0, (long) lL[1]); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 388, (long) -9223371968135299058L); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 384, (int) iL[24]); + long[] callArgs_184 = new long[3]; + callArgs_184[2] = ((long) memory.readInt((int) (iL[31] + 12) < 0 ? (iL[31] + 12) : (iL[31] + 12) + 0)); + callArgs_184[1] = ((long) memory.readInt((int) (iL[31] + 8) < 0 ? (iL[31] + 8) : (iL[31] + 8) + 0)); + callArgs_184[0] = ((long) (iL[23] + 384)); + long[] callResult_184 = instance.getMachine().call(1652, callArgs_184); + long[] callArgs_185 = new long[2]; + callArgs_185[1] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 395), 0) != 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 384) : (iL[23] + 384))); + callArgs_185[0] = ((long) iL[0]); + instance.getMachine().call(52, callArgs_185); + iL[24] = (iL[31] + 20); + iL[37] = (iL[31] + 16); + long[] callArgs_186 = new long[3]; + callArgs_186[2] = ((long) 6356); + callArgs_186[1] = ((long) ((memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0) - memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0)) >> 4)); + callArgs_186[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_186); + label_189: { + iL[30] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + iL[25] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[25], iL[30]) != 0) { + break label_189; + } + label_190: while (true) { + iL[24] = memory.readInt((int) iL[30] < 0 ? iL[30] : iL[30] + 0); + label_191: { + label_192: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(((int) memory.read((int) memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) < 0 ? memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) : memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 20) & 0xFF)) != 0) { + break label_192; + } + long[] callArgs_187 = new long[3]; + callArgs_187[2] = ((long) iL[24]); + callArgs_187[1] = ((long) 0); + callArgs_187[0] = ((long) iL[0]); + instance.getMachine().call(53, callArgs_187); + long[] callArgs_188 = new long[3]; + callArgs_188[2] = ((long) 1564); + callArgs_188[1] = ((long) iL[24]); + callArgs_188[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(170, callArgs_188); + break label_191; + } + long[] callArgs_189 = new long[3]; + callArgs_189[2] = ((long) 1564); + callArgs_189[1] = ((long) iL[24]); + callArgs_189[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_189); + } + iL[37] = (iL[30] + 8); + iL[24] = (iL[30] + 4); + long[] callArgs_190 = new long[3]; + callArgs_190[2] = ((long) 6329); + callArgs_190[1] = ((long) ((memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0)) >> 4)); + callArgs_190[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_190); + label_193: { + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_193; + } + label_194: while (true) { + long[] callArgs_191 = new long[3]; + callArgs_191[2] = ((long) 7253); + callArgs_191[1] = ((long) memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0)); + callArgs_191[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_191); + iL[37] = (iL[24] + 8); + iL[38] = (iL[24] + 4); + long[] callArgs_192 = new long[3]; + callArgs_192[2] = ((long) 14239); + callArgs_192[1] = ((long) (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0) - memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 0))); + callArgs_192[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_192); + iL[38] = memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 0); + long[] callArgs_193 = new long[5]; + callArgs_193[4] = ((long) 1); + callArgs_193[3] = ((long) 26756); + callArgs_193[2] = ((long) (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0) - iL[38])); + callArgs_193[1] = ((long) iL[38]); + callArgs_193[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(224, callArgs_193); + iL[24] = (iL[24] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_194; + } + break; + } + } + iL[30] = (iL[30] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[25], iL[30]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_190; + } + break; + } + } + long[] callArgs_194 = new long[4]; + callArgs_194[3] = ((long) 15012); + callArgs_194[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_194[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_194[0] = ((long) iL[0]); + long[] callResult_194 = instance.getMachine().call(48, callArgs_194); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + label_195: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 395), -1) != 0) { + break label_195; + } + long[] callArgs_195 = new long[1]; + callArgs_195[0] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 384)); + instance.getMachine().call(1777, callArgs_195); + } + iL[31] = memory.readInt((int) iL[31] < 0 ? iL[31] : iL[31] + 0); + if (iL[31] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_188; + } + break; + } + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 0, (int) iL[26]); + long[] callArgs_196 = new long[1]; + callArgs_196[0] = ((long) iL[27]); + long[] callResult_196 = instance.getMachine().call(230, callArgs_196); + iL[24] = ((int) callResult_196[0]); + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 120); + long[] callArgs_197 = new long[4]; + callArgs_197[3] = ((long) (memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 4) - iL[37])); + callArgs_197[2] = ((long) iL[37]); + callArgs_197[1] = ((long) ((iL[37] + memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4)) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0))); + callArgs_197[0] = ((long) iL[38]); + instance.getMachine().call(225, callArgs_197); + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + long[] callArgs_198 = new long[6]; + callArgs_198[5] = ((long) 0); + callArgs_198[4] = ((long) 0); + callArgs_198[3] = ((long) (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4) - iL[37])); + callArgs_198[2] = ((long) iL[37]); + callArgs_198[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 120)); + callArgs_198[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(221, callArgs_198); + long[] callArgs_199 = new long[2]; + callArgs_199[1] = ((long) (memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0))); + callArgs_199[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(220, callArgs_199); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 100, (int) 10); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 120, (int) ((memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4) - iL[37]) + memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 120))); + label_196: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[37]) != 0) { + break label_196; + } + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 4, (int) iL[37]); + long[] callArgs_200 = new long[1]; + callArgs_200[0] = ((long) iL[37]); + instance.getMachine().call(1777, callArgs_200); + } + long[] callArgs_201 = new long[1]; + callArgs_201[0] = ((long) iL[24]); + instance.getMachine().call(1777, callArgs_201); + memory.writeI32((int) iL[27] < 0 ? iL[27] : iL[27] + 0, (int) (41876 + 8)); + iL[24] = memory.readInt((int) iL[27] < 0 ? iL[27] : iL[27] + 16); + memory.writeI32((int) iL[27] < 0 ? iL[27] : iL[27] + 16, (int) 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break _hb; + } + label_197: { + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[37]) != 0) { + break label_197; + } + memory.writeI32((int) iL[24] < 0 ? iL[24] : iL[24] + 4, (int) iL[37]); + long[] callArgs_202 = new long[1]; + callArgs_202[0] = ((long) iL[37]); + instance.getMachine().call(1777, callArgs_202); + } + long[] callArgs_203 = new long[1]; + callArgs_203[0] = ((long) iL[24]); + instance.getMachine().call(1777, callArgs_203); + } while (false); + return _hs[0]; + } + + private static int func_804__h17(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + { + int _sel = iL[4]; + int _sw; + if (_sel < 271) { + _sw = func_804__h17_helper0(_sel, iL, lL, memory, instance); + } else { + _sw = func_804__h17_helper1(_sel, iL, lL, memory, instance); + } + if (_sw != 0) { + _hs[0] = _sw; + break _hb; + } + } + } while (false); + return _hs[0]; + } + + private static int func_41__h8(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 172), memory.readInt((int) (iL[24] + 176) < 0 ? (iL[24] + 176) : (iL[24] + 176) + 0)) != 0) { + break _hb; + } + long[] callArgs_204 = new long[2]; + callArgs_204[1] = ((long) 11); + callArgs_204[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_204); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + long[] callArgs_205 = new long[3]; + callArgs_205[2] = ((long) 7724); + callArgs_205[1] = ((long) ((memory.readInt((int) (iL[24] + 176) < 0 ? (iL[24] + 176) : (iL[24] + 176) + 0) - memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 172)) >> 2)); + callArgs_205[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_205); + label_199: { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 172); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[37], memory.readInt((int) (iL[24] + 176) < 0 ? (iL[24] + 176) : (iL[24] + 176) + 0)) != 0) { + break label_199; + } + iL[26] = (iL[0] + 4); + iL[30] = 0; + label_200: while (true) { + iL[37] = memory.readInt((int) (iL[37] + (iL[30] << 2)) < 0 ? (iL[37] + (iL[30] << 2)) : (iL[37] + (iL[30] << 2)) + 0); + label_201: { + iL[38] = memory.readInt((int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) < 0 ? (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) : (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[38]) != 0) { + break label_201; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 196, (int) iL[30]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 192, (int) 11736); + long[] callArgs_206 = new long[3]; + callArgs_206[2] = ((long) (iL[23] + 192)); + callArgs_206[1] = ((long) 32371); + callArgs_206[0] = ((long) iL[38]); + instance.getMachine().call(223, callArgs_206); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + long[] callArgs_207 = new long[2]; + callArgs_207[1] = ((long) iL[24]); + callArgs_207[0] = ((long) iL[37]); + long[] callResult_207 = instance.getMachine().call(164, callArgs_207); + iL[24] = ((int) callResult_207[0]); + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeByte((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (byte) (iL[24])); + long[] callArgs_208 = new long[5]; + callArgs_208[4] = ((long) 0); + callArgs_208[3] = ((long) 8272); + callArgs_208[2] = ((long) 1); + callArgs_208[1] = ((long) (iL[23] + 560)); + callArgs_208[0] = ((long) iL[38]); + instance.getMachine().call(224, callArgs_208); + label_202: { + if ((iL[24] & 1) != 0) { + break label_202; + } + label_203: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((iL[24] & 2)) != 0) { + break label_203; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ((((int) memory.read((int) memory.readInt((int) iL[26] < 0 ? iL[26] : iL[26] + 0) < 0 ? memory.readInt((int) iL[26] < 0 ? iL[26] : iL[26] + 0) : memory.readInt((int) iL[26] < 0 ? iL[26] : iL[26] + 0) + 15) & 0xFF) & 255)) != 0) { + break label_203; + } + long[] callArgs_209 = new long[2]; + callArgs_209[1] = ((long) (iL[37] + 16)); + callArgs_209[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8)); + long[] callResult_209 = instance.getMachine().call(124, callArgs_209); + long[] callArgs_210 = new long[3]; + callArgs_210[2] = ((long) 2416); + callArgs_210[1] = ((long) ((int) callResult_209[0])); + callArgs_210[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_210); + } + label_204: { + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 52); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_204; + } + label_205: while (true) { + long[] callArgs_211 = new long[3]; + callArgs_211[2] = ((long) iL[24]); + callArgs_211[1] = ((long) 0); + callArgs_211[0] = ((long) iL[0]); + instance.getMachine().call(51, callArgs_211); + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + if (iL[24] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_205; + } + break; + } + } + long[] callArgs_212 = new long[2]; + callArgs_212[1] = ((long) 11); + callArgs_212[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_212); + } + long[] callArgs_213 = new long[3]; + callArgs_213[2] = ((long) 14972); + callArgs_213[1] = ((long) (memory.readInt((int) (iL[37] + 68) < 0 ? (iL[37] + 68) : (iL[37] + 68) + 0) - memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 64))); + callArgs_213[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_213); + label_206: { + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[24] = memory.readInt((int) (iL[31] + 12) < 0 ? (iL[31] + 12) : (iL[31] + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_206; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 180, (int) iL[30]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 176, (int) 26717); + long[] callArgs_214 = new long[3]; + callArgs_214[2] = ((long) (iL[23] + 176)); + callArgs_214[1] = ((long) 32371); + callArgs_214[0] = ((long) iL[24]); + instance.getMachine().call(223, callArgs_214); + iL[31] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + } + label_207: { + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 68); + iL[38] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 64); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[38], iL[24]) != 0) { + break label_207; + } + iL[24] = (iL[24] - iL[38]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LE_S(iL[24], -1) != 0) { + { + _hs[0] = 1; + break _hb; + } + } + long[] callArgs_215 = new long[1]; + callArgs_215[0] = ((long) iL[24]); + long[] callResult_215 = instance.getMachine().call(1776, callArgs_215); + iL[25] = ((int) callResult_215[0]); + label_208: { + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 64); + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 68); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_208; + } + iL[27] = ((iL[24] ^ -1) + iL[36]); + label_209: { + label_210: { + iL[38] = ((iL[36] - iL[24]) & 7); + if (iL[38] != 0) { + break label_210; + } + iL[37] = iL[25]; + break label_209; + } + iL[37] = iL[25]; + label_211: while (true) { + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 0) & 0xFF))); + iL[37] = (iL[37] + 1); + iL[24] = (iL[24] + 1); + iL[38] = (iL[38] + -1); + if (iL[38] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_211; + } + break; + } + } + label_212: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[27], 7) != 0) { + break label_212; + } + label_213: while (true) { + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 0, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 0) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 1, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 1) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 2, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 2) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 3, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 3) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 4, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 4) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 5, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 5) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 6, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 6) & 0xFF))); + memory.writeByte((int) iL[37] < 0 ? iL[37] : iL[37] + 7, (byte) (((int) memory.read((int) iL[24] < 0 ? iL[24] : iL[24] + 7) & 0xFF))); + iL[37] = (iL[37] + 8); + iL[24] = (iL[24] + 8); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_213; + } + break; + } + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[37], iL[25]) != 0) { + break label_208; + } + long[] callArgs_216 = new long[5]; + callArgs_216[4] = ((long) 0); + callArgs_216[3] = ((long) 26717); + callArgs_216[2] = ((long) (iL[37] - iL[25])); + callArgs_216[1] = ((long) iL[25]); + callArgs_216[0] = ((long) iL[31]); + instance.getMachine().call(224, callArgs_216); + } + long[] callArgs_217 = new long[1]; + callArgs_217[0] = ((long) iL[25]); + instance.getMachine().call(1777, callArgs_217); + } + iL[30] = (iL[30] + 1); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[37] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 172); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[30], ((memory.readInt((int) (iL[24] + 176) < 0 ? (iL[24] + 176) : (iL[24] + 176) + 0) - iL[37]) >> 2)) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_200; + } + break; + } + } + long[] callArgs_218 = new long[4]; + callArgs_218[3] = ((long) 15012); + callArgs_218[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_218[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_218[0] = ((long) iL[0]); + long[] callResult_218 = instance.getMachine().call(48, callArgs_218); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } while (false); + return _hs[0]; + } + + private static int func_804__h17_helper0(int _sel, int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + switch(_sel) { + case 0: + { + break _hb; + } + case 1: + { + { + _hs[0] = 20001; + break _hb; + } + } + case 2: + { + { + _hs[0] = 10000; + break _hb; + } + } + case 3: + { + { + _hs[0] = 10001; + break _hb; + } + } + case 4: + { + { + _hs[0] = 10002; + break _hb; + } + } + case 5: + { + { + _hs[0] = 10003; + break _hb; + } + } + case 6: + { + { + _hs[0] = 50000; + break _hb; + } + } + case 7: + { + { + _hs[0] = 50001; + break _hb; + } + } + case 8: + { + { + _hs[0] = 50002; + break _hb; + } + } + case 9: + { + { + _hs[0] = 50003; + break _hb; + } + } + case 10: + { + { + _hs[0] = 50004; + break _hb; + } + } + case 11: + { + { + _hs[0] = 30001; + break _hb; + } + } + case 12: + { + { + _hs[0] = 20002; + break _hb; + } + } + case 13: + { + { + _hs[0] = 20003; + break _hb; + } + } + case 14: + { + { + _hs[0] = 20004; + break _hb; + } + } + case 15: + { + { + _hs[0] = 20005; + break _hb; + } + } + case 16: + { + { + _hs[0] = 30002; + break _hb; + } + } + case 17: + { + { + _hs[0] = 30003; + break _hb; + } + } + case 18: + { + { + _hs[0] = 40000; + break _hb; + } + } + case 19: + { + { + _hs[0] = 40001; + break _hb; + } + } + case 20: + { + { + _hs[0] = 60001; + break _hb; + } + } + case 21: + { + { + _hs[0] = 50005; + break _hb; + } + } + case 22: + { + { + _hs[0] = 50006; + break _hb; + } + } + case 23: + { + { + _hs[0] = 30000; + break _hb; + } + } + case 24: + { + { + _hs[0] = 20006; + break _hb; + } + } + case 25: + { + { + _hs[0] = 20000; + break _hb; + } + } + case 26: + { + { + _hs[0] = 50007; + break _hb; + } + } + case 27: + { + { + _hs[0] = 30004; + break _hb; + } + } + case 28: + { + { + _hs[0] = 30005; + break _hb; + } + } + case 29: + { + { + _hs[0] = 40002; + break _hb; + } + } + case 30: + { + { + _hs[0] = 30006; + break _hb; + } + } + case 31: + { + { + _hs[0] = 30007; + break _hb; + } + } + case 32: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 33: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 34: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 35: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 36: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 37: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 38: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 39: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 40: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 41: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 42: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 43: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 44: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 45: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 46: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 47: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 48: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 49: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 50: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 51: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 52: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 53: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 54: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 55: + { + { + _hs[0] = 40005; + break _hb; + } + } + case 56: + { + { + _hs[0] = 40006; + break _hb; + } + } + case 57: + { + { + _hs[0] = 30008; + break _hb; + } + } + case 58: + { + { + _hs[0] = 30009; + break _hb; + } + } + case 59: + { + { + _hs[0] = 30010; + break _hb; + } + } + case 60: + { + { + _hs[0] = 30011; + break _hb; + } + } + case 61: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 62: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 63: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 64: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 65: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 66: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 67: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 68: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 69: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 70: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 71: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 72: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 73: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 74: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 75: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 76: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 77: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 78: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 79: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 80: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 81: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 82: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 83: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 84: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 85: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 86: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 87: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 88: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 89: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 90: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 91: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 92: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 93: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 94: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 95: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 96: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 97: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 98: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 99: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 100: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 101: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 102: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 103: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 104: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 105: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 106: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 107: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 108: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 109: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 110: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 111: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 112: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 113: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 114: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 115: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 116: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 117: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 118: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 119: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 120: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 121: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 122: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 123: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 124: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 125: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 126: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 127: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 128: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 129: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 130: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 131: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 132: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 133: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 134: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 135: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 136: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 137: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 138: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 139: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 140: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 141: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 142: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 143: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 144: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 145: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 146: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 147: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 148: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 149: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 150: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 151: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 152: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 153: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 154: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 155: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 156: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 157: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 158: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 159: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 160: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 161: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 162: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 163: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 164: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 165: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 166: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 167: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 168: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 169: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 170: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 171: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 172: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 173: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 174: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 175: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 176: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 177: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 178: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 179: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 180: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 181: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 182: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 183: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 184: + { + { + _hs[0] = 50008; + break _hb; + } + } + case 185: + { + { + _hs[0] = 50008; + break _hb; + } + } + case 186: + { + { + _hs[0] = 50008; + break _hb; + } + } + case 187: + { + { + _hs[0] = 50008; + break _hb; + } + } + case 188: + { + { + _hs[0] = 50008; + break _hb; + } + } + case 189: + { + { + _hs[0] = 60002; + break _hb; + } + } + case 190: + { + { + _hs[0] = 60002; + break _hb; + } + } + case 191: + { + { + _hs[0] = 60002; + break _hb; + } + } + case 192: + { + { + _hs[0] = 60002; + break _hb; + } + } + case 193: + { + { + _hs[0] = 60002; + break _hb; + } + } + case 194: + { + { + _hs[0] = 60002; + break _hb; + } + } + case 195: + { + { + _hs[0] = 60002; + break _hb; + } + } + case 196: + { + { + _hs[0] = 50009; + break _hb; + } + } + case 197: + { + { + _hs[0] = 50009; + break _hb; + } + } + case 198: + { + { + _hs[0] = 50009; + break _hb; + } + } + case 199: + { + { + _hs[0] = 50009; + break _hb; + } + } + case 200: + { + { + _hs[0] = 50009; + break _hb; + } + } + case 201: + { + { + _hs[0] = 50009; + break _hb; + } + } + case 202: + { + { + _hs[0] = 50009; + break _hb; + } + } + case 203: + { + { + _hs[0] = 50009; + break _hb; + } + } + case 204: + { + { + _hs[0] = 50010; + break _hb; + } + } + case 205: + { + { + _hs[0] = 50011; + break _hb; + } + } + case 206: + { + { + _hs[0] = 50012; + break _hb; + } + } + case 207: + { + { + _hs[0] = 50013; + break _hb; + } + } + case 208: + { + { + _hs[0] = 50014; + break _hb; + } + } + case 209: + { + { + _hs[0] = 50015; + break _hb; + } + } + case 210: + { + { + _hs[0] = 50016; + break _hb; + } + } + case 211: + { + { + _hs[0] = 50017; + break _hb; + } + } + case 212: + { + { + _hs[0] = 50018; + break _hb; + } + } + case 213: + { + { + _hs[0] = 50019; + break _hb; + } + } + case 214: + { + { + _hs[0] = 60000; + break _hb; + } + } + case 215: + { + { + _hs[0] = 60003; + break _hb; + } + } + case 216: + { + { + _hs[0] = 60004; + break _hb; + } + } + case 217: + { + { + _hs[0] = 60005; + break _hb; + } + } + case 218: + { + { + _hs[0] = 60006; + break _hb; + } + } + case 219: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 220: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 221: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 222: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 223: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 224: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 225: + { + { + _hs[0] = 40003; + break _hb; + } + } + case 226: + { + { + _hs[0] = 40011; + break _hb; + } + } + case 227: + { + { + _hs[0] = 40011; + break _hb; + } + } + case 228: + { + { + _hs[0] = 40011; + break _hb; + } + } + case 229: + { + { + _hs[0] = 40011; + break _hb; + } + } + case 230: + { + { + _hs[0] = 40004; + break _hb; + } + } + case 231: + { + { + _hs[0] = 30012; + break _hb; + } + } + case 232: + { + { + _hs[0] = 40012; + break _hb; + } + } + case 233: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 234: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 235: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 236: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 237: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 238: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 239: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 240: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 241: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 242: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 243: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 244: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 245: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 246: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 247: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 248: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 249: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 250: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 251: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 252: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 253: + { + { + _hs[0] = 40013; + break _hb; + } + } + case 254: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 255: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 256: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 257: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 258: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 259: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 260: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 261: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 262: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 263: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 264: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 265: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 266: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 267: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 268: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 269: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 270: + { + { + _hs[0] = 40008; + break _hb; + } + } + } + } while (false); + return _hs[0]; + } + + private static int func_804__h17_helper1(int _sel, int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + switch(_sel) { + case 271: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 272: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 273: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 274: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 275: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 276: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 277: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 278: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 279: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 280: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 281: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 282: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 283: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 284: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 285: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 286: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 287: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 288: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 289: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 290: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 291: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 292: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 293: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 294: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 295: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 296: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 297: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 298: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 299: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 300: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 301: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 302: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 303: + { + { + _hs[0] = 40015; + break _hb; + } + } + case 304: + { + { + _hs[0] = 40015; + break _hb; + } + } + case 305: + { + { + _hs[0] = 40015; + break _hb; + } + } + case 306: + { + { + _hs[0] = 40015; + break _hb; + } + } + case 307: + { + { + _hs[0] = 40016; + break _hb; + } + } + case 308: + { + { + _hs[0] = 40016; + break _hb; + } + } + case 309: + { + { + _hs[0] = 40016; + break _hb; + } + } + case 310: + { + { + _hs[0] = 40016; + break _hb; + } + } + case 311: + { + { + _hs[0] = 40017; + break _hb; + } + } + case 312: + { + { + _hs[0] = 40017; + break _hb; + } + } + case 313: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 314: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 315: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 316: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 317: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 318: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 319: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 320: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 321: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 322: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 323: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 324: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 325: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 326: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 327: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 328: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 329: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 330: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 331: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 332: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 333: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 334: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 335: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 336: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 337: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 338: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 339: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 340: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 341: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 342: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 343: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 344: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 345: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 346: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 347: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 348: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 349: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 350: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 351: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 352: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 353: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 354: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 355: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 356: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 357: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 358: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 359: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 360: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 361: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 362: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 363: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 364: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 365: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 366: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 367: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 368: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 369: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 370: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 371: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 372: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 373: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 374: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 375: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 376: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 377: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 378: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 379: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 380: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 381: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 382: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 383: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 384: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 385: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 386: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 387: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 388: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 389: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 390: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 391: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 392: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 393: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 394: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 395: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 396: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 397: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 398: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 399: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 400: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 401: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 402: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 403: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 404: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 405: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 406: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 407: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 408: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 409: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 410: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 411: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 412: + { + { + _hs[0] = 40008; + break _hb; + } + } + case 413: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 414: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 415: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 416: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 417: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 418: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 419: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 420: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 421: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 422: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 423: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 424: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 425: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 426: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 427: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 428: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 429: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 430: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 431: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 432: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 433: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 434: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 435: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 436: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 437: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 438: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 439: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 440: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 441: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 442: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 443: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 444: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 445: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 446: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 447: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 448: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 449: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 450: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 451: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 452: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 453: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 454: + { + { + _hs[0] = 40007; + break _hb; + } + } + case 455: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 456: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 457: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 458: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 459: + { + { + _hs[0] = 40009; + break _hb; + } + } + case 460: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 461: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 462: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 463: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 464: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 465: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 466: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 467: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 468: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 469: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 470: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 471: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 472: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 473: + { + { + _hs[0] = 40010; + break _hb; + } + } + case 474: + { + { + _hs[0] = 40014; + break _hb; + } + } + case 475: + { + { + _hs[0] = 50020; + break _hb; + } + } + case 476: + { + { + _hs[0] = 50021; + break _hb; + } + } + case 477: + { + { + _hs[0] = 50021; + break _hb; + } + } + case 478: + { + { + _hs[0] = 50022; + break _hb; + } + } + case 479: + { + { + _hs[0] = 50023; + break _hb; + } + } + case 480: + { + { + _hs[0] = 50023; + break _hb; + } + } + case 481: + { + { + _hs[0] = 50023; + break _hb; + } + } + case 482: + { + { + _hs[0] = 50023; + break _hb; + } + } + case 483: + { + { + _hs[0] = 50023; + break _hb; + } + } + case 484: + { + { + _hs[0] = 50023; + break _hb; + } + } + case 485: + { + { + _hs[0] = 50023; + break _hb; + } + } + case 486: + { + { + _hs[0] = 50024; + break _hb; + } + } + case 487: + { + { + _hs[0] = 50024; + break _hb; + } + } + case 488: + { + { + _hs[0] = 50024; + break _hb; + } + } + case 489: + { + { + _hs[0] = 50024; + break _hb; + } + } + case 490: + { + { + _hs[0] = 50024; + break _hb; + } + } + case 491: + { + { + _hs[0] = 50024; + break _hb; + } + } + case 492: + { + { + _hs[0] = 50024; + break _hb; + } + } + case 493: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 494: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 495: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 496: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 497: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 498: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 499: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 500: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 501: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 502: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 503: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 504: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 505: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 506: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 507: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 508: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 509: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 510: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 511: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 512: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 513: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 514: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 515: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 516: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 517: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 518: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 519: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 520: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 521: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 522: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 523: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 524: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 525: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 526: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 527: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 528: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 529: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 530: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 531: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 532: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 533: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 534: + { + { + _hs[0] = 50025; + break _hb; + } + } + case 535: + { + { + _hs[0] = 50026; + break _hb; + } + } + case 536: + { + { + _hs[0] = 50026; + break _hb; + } + } + case 537: + { + { + _hs[0] = 50026; + break _hb; + } + } + case 538: + { + { + _hs[0] = 50026; + break _hb; + } + } + case 539: + { + { + _hs[0] = 50026; + break _hb; + } + } + case 540: + { + { + _hs[0] = 50026; + break _hb; + } + } + case 541: + { + { + _hs[0] = 50026; + break _hb; + } + } + default: + { + { + _hs[0] = 60002; + break _hb; + } + } + } + } while (false); + return _hs[0]; + } + + private static int func_41__h9(int[] iL, long[] lL, com.dylibso.chicory.runtime.Memory memory, com.dylibso.chicory.runtime.Instance instance) { + int[] _hs = { 0 }; + _hb: do { + if (iL[27] != 0) { + break _hb; + } + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 120, (int) memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + long[] callArgs_162 = new long[2]; + callArgs_162[1] = ((long) 10); + callArgs_162[0] = ((long) iL[0]); + instance.getMachine().call(47, callArgs_162); + long[] callArgs_163 = new long[3]; + callArgs_163[2] = ((long) 7922); + callArgs_163[1] = ((long) iL[26]); + callArgs_163[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_163); + iL[27] = 0; + label_167: while (true) { + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + iL[38] = (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 48) + iL[27]); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 160, (int) iL[38]); + label_168: { + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[36] = memory.readInt((int) (iL[24] + 12) < 0 ? (iL[24] + 12) : (iL[24] + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[36]) != 0) { + break label_168; + } + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 212, (int) iL[27]); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 208, (int) 1296); + long[] callArgs_164 = new long[3]; + callArgs_164[2] = ((long) (iL[23] + 208)); + callArgs_164[1] = ((long) 32371); + callArgs_164[0] = ((long) iL[36]); + instance.getMachine().call(223, callArgs_164); + iL[24] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 160); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 8); + } + iL[38] = memory.readInt((int) (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 76) + (iL[38] << 2)) < 0 ? (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 76) + (iL[38] << 2)) : (memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 76) + (iL[38] << 2)) + 0); + iL[37] = ((int) memory.read((int) (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) < 0 ? (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) : (memory.readInt((int) (iL[0] + 4) < 0 ? (iL[0] + 4) : (iL[0] + 4) + 0) + 19) + 0) & 0xFF); + memory.writeByte((int) ((iL[23] + 560) + 4) < 0 ? ((iL[23] + 560) + 4) : ((iL[23] + 560) + 4) + 0, (byte) (0)); + memory.writeI32((int) iL[23] < 0 ? iL[23] : iL[23] + 560, (int) 0); + iL[25] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + long[] callArgs_165 = new long[5]; + callArgs_165[4] = ((long) 0); + callArgs_165[3] = ((long) 30143); + callArgs_165[2] = ((long) (iL[37] != 0 ? 1 : 5)); + callArgs_165[1] = ((long) (iL[23] + 560)); + callArgs_165[0] = ((long) iL[24]); + instance.getMachine().call(224, callArgs_165); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 156, (int) memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4)); + label_169: { + label_170: { + long[] callArgs_166 = new long[1]; + callArgs_166[0] = ((long) (iL[38] + 116)); + long[] callResult_166 = instance.getMachine().call(130, callArgs_166); + if (((int) callResult_166[0]) != 0) { + break label_170; + } + long[] callArgs_167 = new long[3]; + callArgs_167[2] = ((long) 6489); + callArgs_167[1] = ((long) 0); + callArgs_167[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_167); + break label_169; + } + iL[37] = (iL[38] + 120); + long[] callArgs_168 = new long[3]; + callArgs_168[2] = ((long) 6489); + callArgs_168[1] = ((long) com.dylibso.chicory.runtime.OpcodeImpl.I32_DIV_S((memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0) - memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 116)), 12)); + callArgs_168[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_168); + iL[24] = memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 116); + iL[36] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_169; + } + label_171: while (true) { + lL[0] = memory.readLong((int) iL[24] < 0 ? iL[24] : iL[24] + 0); + long[] callArgs_169 = new long[3]; + callArgs_169[2] = ((long) 6578); + callArgs_169[1] = ((long) memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 8)); + callArgs_169[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(169, callArgs_169); + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0); + memory.writeLong((int) iL[23] < 0 ? iL[23] : iL[23] + 384, (long) lL[0]); + long[] callArgs_170 = new long[2]; + callArgs_170[1] = ((long) (iL[23] + 384)); + callArgs_170[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(38, callArgs_170); + long[] callArgs_171 = new long[3]; + callArgs_171[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), 0) != 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) : (iL[23] + 560))); + callArgs_171[1] = ((long) (int) lL[0]); + callArgs_171[0] = ((long) iL[37]); + instance.getMachine().call(173, callArgs_171); + label_172: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), -1) != 0) { + break label_172; + } + long[] callArgs_172 = new long[1]; + callArgs_172[0] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560)); + instance.getMachine().call(1777, callArgs_172); + } + label_173: { + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(-21, memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 384)) != 0) { + break label_173; + } + iL[30] = memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 388); + long[] callArgs_173 = new long[2]; + callArgs_173[1] = ((long) (iL[23] + 384)); + callArgs_173[0] = ((long) (iL[23] + 560)); + instance.getMachine().call(38, callArgs_173); + long[] callArgs_174 = new long[3]; + callArgs_174[2] = ((long) (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), 0) != 0 ? memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560) : (iL[23] + 560))); + callArgs_174[1] = ((long) iL[30]); + callArgs_174[0] = ((long) iL[37]); + instance.getMachine().call(173, callArgs_174); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_S((int) (byte) memory.read((int) iL[23] < 0 ? iL[23] : iL[23] + 571), -1) != 0) { + break label_173; + } + long[] callArgs_175 = new long[1]; + callArgs_175[0] = ((long) memory.readInt((int) iL[23] < 0 ? iL[23] : iL[23] + 560)); + instance.getMachine().call(1777, callArgs_175); + } + iL[24] = (iL[24] + 12); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_171; + } + break; + } + } + label_174: { + iL[24] = memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 148); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[24]) != 0) { + break label_174; + } + label_175: while (true) { + long[] callArgs_176 = new long[3]; + callArgs_176[2] = ((long) iL[24]); + callArgs_176[1] = ((long) iL[38]); + callArgs_176[0] = ((long) iL[0]); + instance.getMachine().call(51, callArgs_176); + iL[24] = memory.readInt((int) iL[24] < 0 ? iL[24] : iL[24] + 4); + if (iL[24] != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_175; + } + break; + } + } + long[] callArgs_177 = new long[2]; + callArgs_177[1] = ((long) 11); + callArgs_177[0] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0)); + instance.getMachine().call(36, callArgs_177); + iL[38] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 104); + iL[28] = memory.readInt((int) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) < 0 ? memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) : memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 0) + 4); + label_176: { + long[] callArgs_178 = new long[4]; + callArgs_178[3] = ((long) 14951); + callArgs_178[2] = ((long) 1); + callArgs_178[1] = ((long) iL[25]); + callArgs_178[0] = ((long) iL[0]); + long[] callResult_178 = instance.getMachine().call(48, callArgs_178); + iL[31] = ((int) callResult_178[0]); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[31]) != 0) { + break label_176; + } + iL[37] = memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 84); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQZ(iL[37]) != 0) { + break label_176; + } + iL[24] = memory.readInt((int) iL[37] < 0 ? iL[37] : iL[37] + 8); + iL[36] = memory.readInt((int) (iL[37] + 12) < 0 ? (iL[37] + 12) : (iL[37] + 12) + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_EQ(iL[36], iL[24]) != 0) { + break label_176; + } + iL[30] = (iL[25] - iL[38]); + iL[25] = (iL[28] - iL[38]); + label_177: while (true) { + label_178: { + iL[38] = (iL[24] + 4); + iL[37] = memory.readInt((int) iL[38] < 0 ? iL[38] : iL[38] + 0); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_LT_U(iL[37], iL[30]) != 0) { + break label_178; + } + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_GT_U(iL[37], iL[25]) != 0) { + break label_178; + } + memory.writeI32((int) iL[38] < 0 ? iL[38] : iL[38] + 0, (int) (iL[37] + iL[31])); + } + iL[24] = (iL[24] + 16); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[36], iL[24]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_177; + } + break; + } + } + iL[27] = (iL[27] + 1); + if (com.dylibso.chicory.runtime.OpcodeImpl.I32_NE(iL[26], iL[27]) != 0) { + if (Thread.currentThread().isInterrupted()) + throw new com.dylibso.chicory.runtime.ChicoryInterruptedException("Thread interrupted"); + continue label_167; + } + break; + } + long[] callArgs_179 = new long[4]; + callArgs_179[3] = ((long) 15012); + callArgs_179[2] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 96)); + callArgs_179[1] = ((long) memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 92)); + callArgs_179[0] = ((long) iL[0]); + long[] callResult_179 = instance.getMachine().call(48, callArgs_179); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 96, (int) 0); + memory.writeI32((int) iL[0] < 0 ? iL[0] : iL[0] + 88, (int) (memory.readInt((int) iL[0] < 0 ? iL[0] : iL[0] + 88) + 1)); + } while (false); + return _hs[0]; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Wat2WasmModule.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Wat2WasmModule.java new file mode 100644 index 000000000..2622cb029 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/Wat2WasmModule.java @@ -0,0 +1,35 @@ +package com.dylibso.chicory.wabt; + +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.runtime.Machine; +import com.dylibso.chicory.wasm.Parser; +import com.dylibso.chicory.wasm.WasmModule; +import java.io.IOException; +import java.io.InputStream; +import java.io.UncheckedIOException; + +public final class Wat2WasmModule { + + private Wat2WasmModule() {} + + public static Machine create(Instance instance) { + return new Wat2WasmMachine(instance); + } + + private static class WasmModuleHolder { + + static final WasmModule INSTANCE; + + static { + try (InputStream in = Wat2WasmModule.class.getResourceAsStream("Wat2WasmModule.meta")) { + INSTANCE = Parser.parse(in); + } catch (IOException e) { + throw new UncheckedIOException("Failed to load .meta WASM module", e); + } + } + } + + public static WasmModule load() { + return WasmModuleHolder.INSTANCE; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/WatParseException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/WatParseException.java new file mode 100644 index 000000000..5840b65f9 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wabt/WatParseException.java @@ -0,0 +1,14 @@ +package com.dylibso.chicory.wabt; + +public class WatParseException extends RuntimeException { + + public WatParseException() {} + + public WatParseException(String message) { + super(message); + } + + public WatParseException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/Descriptors.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/Descriptors.java new file mode 100644 index 000000000..05e41c0db --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/Descriptors.java @@ -0,0 +1,195 @@ +package com.dylibso.chicory.wasi; + +import static java.util.Objects.requireNonNull; + +import java.io.Closeable; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.nio.ByteBuffer; +import java.nio.channels.FileChannel; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.NavigableSet; +import java.util.TreeSet; + +final class Descriptors { + private final List descriptors = new ArrayList<>(); + private final NavigableSet freeFds = new TreeSet<>(); + + public Descriptor get(int fd) { + if (fd < 0 || fd >= descriptors.size()) { + return null; + } + return descriptors.get(fd); + } + + public int allocate(Descriptor descriptor) { + Integer fd = freeFds.pollFirst(); + if (fd != null) { + descriptors.set(fd, descriptor); + return fd; + } + descriptors.add(descriptor); + return descriptors.size() - 1; + } + + public void free(int fd) { + descriptors.set(fd, null); + freeFds.add(fd); + } + + public void set(int fd, Descriptor descriptor) { + descriptors.set(fd, descriptor); + } + + public void closeAll() { + RuntimeException exception = null; + for (var descriptor : descriptors) { + try { + if (descriptor instanceof Closeable) { + ((Closeable) descriptor).close(); + } + } catch (Throwable t) { + if (exception == null) { + exception = new RuntimeException(); + } + exception.addSuppressed(t); + } + } + if (exception != null) { + throw exception; + } + } + + interface Descriptor {} + + interface DataReader { + int read(byte[] data) throws IOException; + } + + interface DataWriter { + int write(byte[] data) throws IOException; + } + + interface Directory { + Path path(); + } + + static final class InStream implements Descriptor, DataReader { + private final InputStream in; + + public InStream(InputStream in) { + this.in = requireNonNull(in); + } + + @Override + public int read(byte[] data) throws IOException { + return in.read(data); + } + + public int available() throws IOException { + return in.available(); + } + } + + static final class OutStream implements Descriptor, DataWriter { + private final OutputStream out; + + public OutStream(OutputStream out) { + this.out = requireNonNull(out); + } + + @Override + public int write(byte[] data) throws IOException { + out.write(data); + return data.length; + } + } + + static final class PreopenedDirectory implements Descriptor, Directory { + private final byte[] name; + private final Path path; + + public PreopenedDirectory(byte[] name, Path path) { + this.name = requireNonNull(name); + this.path = requireNonNull(path); + } + + public byte[] name() { + return name; + } + + @Override + public Path path() { + return path; + } + } + + static final class OpenDirectory implements Descriptor, Directory { + private final Path path; + + public OpenDirectory(Path path) { + this.path = requireNonNull(path); + } + + @Override + public Path path() { + return path; + } + } + + static final class OpenFile implements Descriptor, Closeable, DataReader, DataWriter { + private final Path path; + private final FileChannel channel; + private final int fdFlags; + private final long rights; + + public OpenFile(Path path, FileChannel channel, int fdFlags, long rights) { + this.path = requireNonNull(path); + this.channel = requireNonNull(channel); + this.fdFlags = fdFlags; + this.rights = rights; + } + + public Path path() { + return path; + } + + public FileChannel channel() { + return channel; + } + + public int fdFlags() { + return fdFlags; + } + + public long rights() { + return rights; + } + + @Override + public int read(byte[] data) throws IOException { + return channel.read(ByteBuffer.wrap(data)); + } + + public int read(byte[] data, long position) throws IOException { + return channel.read(ByteBuffer.wrap(data), position); + } + + @Override + public int write(byte[] data) throws IOException { + return channel.write(ByteBuffer.wrap(data)); + } + + public int write(byte[] data, long position) throws IOException { + return channel.write(ByteBuffer.wrap(data), position); + } + + @Override + public void close() throws IOException { + channel.close(); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/Files.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/Files.java new file mode 100644 index 000000000..240161cd2 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/Files.java @@ -0,0 +1,64 @@ +package com.dylibso.chicory.wasi; + +import static java.nio.file.Files.copy; +import static java.nio.file.Files.createDirectory; +import static java.nio.file.Files.getFileAttributeView; +import static java.nio.file.Files.isSymbolicLink; +import static java.nio.file.Files.walkFileTree; + +import java.io.IOException; +import java.nio.file.FileVisitResult; +import java.nio.file.Path; +import java.nio.file.SimpleFileVisitor; +import java.nio.file.StandardCopyOption; +import java.nio.file.attribute.BasicFileAttributes; +import java.nio.file.attribute.FileAttribute; +import java.nio.file.attribute.PosixFileAttributeView; +import java.nio.file.attribute.PosixFilePermissions; + +public final class Files { + private Files() {} + + /** + * Copy directory recursively, including POSIX file permissions. + */ + public static void copyDirectory(Path source, Path target) throws IOException { + walkFileTree( + source, + new SimpleFileVisitor<>() { + @Override + public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) + throws IOException { + if (isSymbolicLink(dir)) { + return FileVisitResult.SKIP_SUBTREE; + } + + Path directory = target.resolve(source.relativize(dir).toString()); + + if (!directory.toString().equals("/")) { + FileAttribute[] attributes = new FileAttribute[0]; + var attributeView = + getFileAttributeView(dir, PosixFileAttributeView.class); + if (attributeView != null) { + var permissions = attributeView.readAttributes().permissions(); + var attribute = PosixFilePermissions.asFileAttribute(permissions); + attributes = new FileAttribute[] {attribute}; + } + + createDirectory(directory, attributes); + } + + return FileVisitResult.CONTINUE; + } + + @Override + public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) + throws IOException { + String relative = source.relativize(file).toString().replace("\\", "/"); + Path path = target.resolve(relative); + copy(file, path, StandardCopyOption.COPY_ATTRIBUTES); + return FileVisitResult.CONTINUE; + } + }); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/IO.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/IO.java new file mode 100644 index 000000000..9c09f337e --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/IO.java @@ -0,0 +1,132 @@ +package com.dylibso.chicory.wasi; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.Objects; + +/** + * Provides implementations of null stream utilities that are compatible with Android + * devices running API levels below 33. This class contains implementations equivalent to + * {@code OutputStream.nullOutputStream()} and {@code InputStream.nullInputStream()} + * which were introduced in Android API Level 33. + */ +final class IO { + private IO() {} + + /** + * Returns an {@link OutputStream} that discards all bytes written to it. + * This implementation provides compatibility for Android devices running below API Level 33, + * where {@code OutputStream.nullOutputStream()} is not available. + * + * @return an output stream that discards all bytes written to it + */ + public static OutputStream nullOutputStream() { + return new OutputStream() { + private volatile boolean closed; + + private void ensureOpen() throws IOException { + if (closed) { + throw new IOException("Stream closed"); + } + } + + @Override + public void write(int b) throws IOException { + ensureOpen(); + } + + @Override + public void write(byte[] b, int off, int len) throws IOException { + Objects.checkFromIndexSize(off, len, b.length); + ensureOpen(); + } + + @Override + public void close() { + closed = true; + } + }; + } + + /** + * Returns an {@link InputStream} that contains no bytes. + * This implementation provides compatibility for Android devices running below API Level 33, + * where {@code InputStream.nullInputStream()} is not available. + * + * @return an input stream that contains no bytes + */ + public static InputStream nullInputStream() { + return new InputStream() { + private volatile boolean closed; + + private void ensureOpen() throws IOException { + if (closed) { + throw new IOException("Stream closed"); + } + } + + @Override + public int available() throws IOException { + ensureOpen(); + return 0; + } + + @Override + public int read() throws IOException { + ensureOpen(); + return -1; + } + + @Override + public int read(byte[] b, int off, int len) throws IOException { + Objects.checkFromIndexSize(off, len, b.length); + if (len == 0) { + return 0; + } + ensureOpen(); + return -1; + } + + @Override + public byte[] readAllBytes() throws IOException { + ensureOpen(); + return new byte[0]; + } + + @Override + public int readNBytes(byte[] b, int off, int len) throws IOException { + Objects.checkFromIndexSize(off, len, b.length); + ensureOpen(); + return 0; + } + + @Override + public byte[] readNBytes(int len) throws IOException { + if (len < 0) { + throw new IllegalArgumentException("len < 0"); + } + ensureOpen(); + return new byte[0]; + } + + @Override + public long skip(long n) throws IOException { + ensureOpen(); + return 0L; + } + + @Override + public long transferTo(OutputStream out) throws IOException { + Objects.requireNonNull(out); + ensureOpen(); + return 0L; + } + + @Override + public void close() throws IOException { + closed = true; + } + }; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiClockId.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiClockId.java new file mode 100644 index 000000000..1e63cf05e --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiClockId.java @@ -0,0 +1,13 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI clockid + */ +final class WasiClockId { + private WasiClockId() {} + + public static final int REALTIME = 0; + public static final int MONOTONIC = 1; + public static final int PROCESS_CPUTIME_ID = 2; + public static final int THREAD_CPUTIME_ID = 3; +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiErrno.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiErrno.java new file mode 100644 index 000000000..06f188680 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiErrno.java @@ -0,0 +1,89 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI errno + */ +enum WasiErrno { + ESUCCESS, + E2BIG, + EACCES, + EADDRINUSE, + EADDRNOTAVAIL, + EAFNOSUPPORT, + EAGAIN, + EALREADY, + EBADF, + EBADMSG, + EBUSY, + ECANCELED, + ECHILD, + ECONNABORTED, + ECONNREFUSED, + ECONNRESET, + EDEADLK, + EDESTADDRREQ, + EDOM, + EDQUOT, + EEXIST, + EFAULT, + EFBIG, + EHOSTUNREACH, + EIDRM, + EILSEQ, + EINPROGRESS, + EINTR, + EINVAL, + EIO, + EISCONN, + EISDIR, + ELOOP, + EMFILE, + EMLINK, + EMSGSIZE, + EMULTIHOP, + ENAMETOOLONG, + ENETDOWN, + ENETRESET, + ENETUNREACH, + ENFILE, + ENOBUFS, + ENODEV, + ENOENT, + ENOEXEC, + ENOLCK, + ENOLINK, + ENOMEM, + ENOMSG, + ENOPROTOOPT, + ENOSPC, + ENOSYS, + ENOTCONN, + ENOTDIR, + ENOTEMPTY, + ENOTRECOVERABLE, + ENOTSOCK, + ENOTSUP, + ENOTTY, + ENXIO, + EOVERFLOW, + EOWNERDEAD, + EPERM, + EPIPE, + EPROTO, + EPROTONOSUPPORT, + EPROTOTYPE, + ERANGE, + EROFS, + ESPIPE, + ESRCH, + ESTALE, + ETIMEDOUT, + ETXTBSY, + EXDEV, + ENOTCAPABLE; + + @SuppressWarnings("EnumOrdinal") + public int value() { + return ordinal(); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiEventType.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiEventType.java new file mode 100644 index 000000000..431174c53 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiEventType.java @@ -0,0 +1,12 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI eventtype + */ +final class WasiEventType { + private WasiEventType() {} + + public static final byte CLOCK = 0; + public static final byte FD_READ = 1; + public static final byte FD_WRITE = 2; +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiExitException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiExitException.java new file mode 100644 index 000000000..0fd0fe954 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiExitException.java @@ -0,0 +1,22 @@ +package com.dylibso.chicory.wasi; + +import com.dylibso.chicory.wasm.ChicoryException; + +public class WasiExitException extends ChicoryException { + private final int exitCode; + + public WasiExitException(int exitCode) { + super("Process exit code: " + exitCode); + this.exitCode = exitCode; + } + + public int exitCode() { + return exitCode; + } + + // no need to capture the Stack Trace + @Override + public Throwable fillInStackTrace() { + return this; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiFdFlags.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiFdFlags.java new file mode 100644 index 000000000..5f56caf3c --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiFdFlags.java @@ -0,0 +1,18 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI fdflags + */ +final class WasiFdFlags { + private WasiFdFlags() {} + + public static final int APPEND = bit(0); + public static final int DSYNC = bit(1); + public static final int NONBLOCK = bit(2); + public static final int RSYNC = bit(3); + public static final int SYNC = bit(4); + + private static int bit(int n) { + return 1 << n; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiFileType.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiFileType.java new file mode 100644 index 000000000..4cffa1da9 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiFileType.java @@ -0,0 +1,20 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI filetype + */ +enum WasiFileType { + UNKNOWN, + BLOCK_DEVICE, + CHARACTER_DEVICE, + DIRECTORY, + REGULAR_FILE, + SOCKET_DGRAM, + SOCKET_STREAM, + SYMBOLIC_LINK; + + @SuppressWarnings("EnumOrdinal") + public int value() { + return ordinal(); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiFstFlags.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiFstFlags.java new file mode 100644 index 000000000..1b9afd0a4 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiFstFlags.java @@ -0,0 +1,17 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI fstflags + */ +final class WasiFstFlags { + private WasiFstFlags() {} + + public static final int ATIM = bit(0); + public static final int ATIM_NOW = bit(1); + public static final int MTIM = bit(2); + public static final int MTIM_NOW = bit(3); + + private static int bit(int n) { + return 1 << n; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiLookupFlags.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiLookupFlags.java new file mode 100644 index 000000000..a9f2dbe4c --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiLookupFlags.java @@ -0,0 +1,10 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI lookupflags flags + */ +final class WasiLookupFlags { + private WasiLookupFlags() {} + + public static final int SYMLINK_FOLLOW = 1; +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiOpenFlags.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiOpenFlags.java new file mode 100644 index 000000000..5938c04af --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiOpenFlags.java @@ -0,0 +1,17 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI oflags + */ +final class WasiOpenFlags { + private WasiOpenFlags() {} + + public static final int CREAT = bit(0); + public static final int DIRECTORY = bit(1); + public static final int EXCL = bit(2); + public static final int TRUNC = bit(3); + + private static int bit(int n) { + return 1 << n; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiOptions.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiOptions.java new file mode 100644 index 000000000..e9c9efbe3 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiOptions.java @@ -0,0 +1,147 @@ +package com.dylibso.chicory.wasi; + +import static java.util.Collections.unmodifiableMap; +import static java.util.Objects.requireNonNull; + +import java.io.InputStream; +import java.io.OutputStream; +import java.nio.file.Path; +import java.time.Clock; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.concurrent.ThreadLocalRandom; + +public final class WasiOptions { + private final Random random; + private final Clock clock; + private final OutputStream stdout; + private final OutputStream stderr; + private final InputStream stdin; + private final List arguments; + private final Map environment; + private final Map directories; + + public static Builder builder() { + return new Builder(); + } + + private WasiOptions( + Random random, + Clock clock, + OutputStream stdout, + OutputStream stderr, + InputStream stdin, + List arguments, + Map environment, + Map directories) { + this.random = requireNonNull(random); + this.clock = requireNonNull(clock); + this.stdout = requireNonNull(stdout); + this.stderr = requireNonNull(stderr); + this.stdin = requireNonNull(stdin); + this.arguments = List.copyOf(arguments); + this.environment = unmodifiableMap(new LinkedHashMap<>(environment)); + this.directories = unmodifiableMap(new LinkedHashMap<>(directories)); + } + + public Random random() { + return random; + } + + public Clock clock() { + return clock; + } + + public OutputStream stdout() { + return stdout; + } + + public OutputStream stderr() { + return stderr; + } + + public InputStream stdin() { + return stdin; + } + + public List arguments() { + return arguments; + } + + public Map environment() { + return environment; + } + + public Map directories() { + return directories; + } + + public static final class Builder { + // ThreadLocalRandom is correctly substituted in graal native-image: + // https://github.com/oracle/graal/blob/f63ba1767a34d9a4e9d747d077d684f20f4d934d/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/ThreadLocalRandomAccessors.java#L38 + private Random random = ThreadLocalRandom.current(); + private Clock clock = Clock.systemUTC(); + private OutputStream stdout = IO.nullOutputStream(); + private OutputStream stderr = IO.nullOutputStream(); + private InputStream stdin = IO.nullInputStream(); + private List arguments = List.of(); + private final Map environment = new LinkedHashMap<>(); + private final Map directories = new LinkedHashMap<>(); + + private Builder() {} + + public Builder withRandom(Random random) { + this.random = random; + return this; + } + + public Builder withClock(Clock clock) { + this.clock = clock; + return this; + } + + public Builder withStdout(OutputStream stdout) { + this.stdout = stdout; + return this; + } + + public Builder withStderr(OutputStream stderr) { + this.stderr = stderr; + return this; + } + + public Builder withStdin(InputStream stdin) { + this.stdin = stdin; + return this; + } + + public Builder inheritSystem() { + this.stdout = System.out; + this.stdin = System.in; + this.stderr = System.err; + return this; + } + + public Builder withArguments(List arguments) { + this.arguments = List.copyOf(arguments); + return this; + } + + public Builder withEnvironment(String name, String value) { + this.environment.put(name, value); + return this; + } + + public Builder withDirectory(String guest, Path host) { + this.directories.put(guest, host); + return this; + } + + public WasiOptions build() { + return new WasiOptions( + random, clock, stdout, stderr, stdin, arguments, environment, directories); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiPreview1.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiPreview1.java new file mode 100644 index 000000000..9754166fd --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiPreview1.java @@ -0,0 +1,1901 @@ +package com.dylibso.chicory.wasi; + +import static com.dylibso.chicory.wasi.Descriptors.DataReader; +import static com.dylibso.chicory.wasi.Descriptors.DataWriter; +import static com.dylibso.chicory.wasi.Descriptors.Descriptor; +import static com.dylibso.chicory.wasi.Descriptors.OpenDirectory; +import static com.dylibso.chicory.wasi.Descriptors.OpenFile; +import static java.lang.Math.max; +import static java.lang.Math.min; +import static java.nio.charset.StandardCharsets.UTF_8; +import static java.util.Objects.requireNonNull; +import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static java.util.concurrent.TimeUnit.SECONDS; +import static java.util.stream.Collectors.toList; + +//import com.dylibso.chicory.annotations.Buffer; +// import com.dylibso.chicory.annotations.HostModule; +// import com.dylibso.chicory.annotations.WasmExport; +import com.dylibso.chicory.log.BasicLogger; +import com.dylibso.chicory.log.Logger; +import com.dylibso.chicory.log.SystemLogger; +import com.dylibso.chicory.runtime.HostFunction; +import com.dylibso.chicory.runtime.Memory; +import com.dylibso.chicory.runtime.WasmRuntimeException; +import com.dylibso.chicory.wasi.Descriptors.Directory; +import com.dylibso.chicory.wasi.Descriptors.InStream; +import com.dylibso.chicory.wasi.Descriptors.OutStream; +import com.dylibso.chicory.wasi.Descriptors.PreopenedDirectory; +import com.dylibso.chicory.wasm.ChicoryException; +import java.io.Closeable; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.channels.FileChannel; +import java.nio.channels.NonReadableChannelException; +import java.nio.channels.NonWritableChannelException; +import java.nio.channels.SeekableByteChannel; +import java.nio.file.AtomicMoveNotSupportedException; +import java.nio.file.DirectoryNotEmptyException; +import java.nio.file.FileAlreadyExistsException; +import java.nio.file.Files; +import java.nio.file.InvalidPathException; +import java.nio.file.LinkOption; +import java.nio.file.NoSuchFileException; +import java.nio.file.NotDirectoryException; +import java.nio.file.NotLinkException; +import java.nio.file.OpenOption; +import java.nio.file.Path; +import java.nio.file.StandardCopyOption; +import java.nio.file.StandardOpenOption; +import java.nio.file.attribute.BasicFileAttributeView; +import java.nio.file.attribute.BasicFileAttributes; +import java.nio.file.attribute.FileTime; +import java.time.Clock; +import java.time.Instant; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Random; +import java.util.Set; +import java.util.stream.Stream; + +/** + * WASI preview 1 implementation + */ +// @HostModule("wasi_snapshot_preview1") +public final class WasiPreview1 implements Closeable { + private final Logger logger; + private final Random random; + private final Clock clock; + private final List arguments; + private final List> environment; + private final Descriptors descriptors = new Descriptors(); + + private WasiPreview1(Logger logger, WasiOptions opts) { + // TODO by default everything should by blocked + // this works now because streams are null. + // maybe we want a more explicit way of doing this though + this.logger = requireNonNull(logger); + this.random = opts.random(); + this.clock = opts.clock(); + this.arguments = + opts.arguments().stream().map(value -> value.getBytes(UTF_8)).collect(toList()); + this.environment = + opts.environment().entrySet().stream() + .map( + x -> + Map.entry( + x.getKey().getBytes(UTF_8), + x.getValue().getBytes(UTF_8))) + .collect(toList()); + + descriptors.allocate(new InStream(opts.stdin())); + descriptors.allocate(new OutStream(opts.stdout())); + descriptors.allocate(new OutStream(opts.stderr())); + + for (var entry : opts.directories().entrySet()) { + byte[] name = entry.getKey().getBytes(UTF_8); + descriptors.allocate(new PreopenedDirectory(name, entry.getValue())); + } + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private Logger logger; + private WasiOptions opts; + + private Builder() {} + + public Builder withLogger(Logger logger) { + this.logger = logger; + return this; + } + + public Builder withOptions(WasiOptions opts) { + this.opts = opts; + return this; + } + + private static boolean isAndroid() { + try { + Class.forName("android.os.Build"); + return true; + } catch (ClassNotFoundException e) { + // Fallback: check known system property + String runtime = System.getProperty("java.runtime.name"); + return runtime != null && runtime.toLowerCase(Locale.ENGLISH).contains("android"); + } + } + + public WasiPreview1 build() { + if (logger == null && isAndroid()) { + logger = new BasicLogger(); + } else if (logger == null) { + logger = new SystemLogger(); + } + if (opts == null) { + opts = WasiOptions.builder().build(); + } + return new WasiPreview1(logger, opts); + } + } + + @Override + public void close() { + descriptors.closeAll(); + } + + //@WasmExport + public int adapterCloseBadfd(int fd) { + logger.tracef("adapter_close_badfd: [%s]", fd); + throw new WasmRuntimeException("We don't yet support this WASI call: adapter_close_badfd"); + } + + //@WasmExport + public int adapterOpenBadfd(int fd) { + logger.tracef("adapter_open_badfd: [%s]", fd); + throw new WasmRuntimeException("We don't yet support this WASI call: adapter_open_badfd"); + } + + //@WasmExport + public int argsGet(Memory memory, int argv, int argvBuf) { + logger.tracef("args_get: [%s, %s]", argv, argvBuf); + for (byte[] argument : arguments) { + memory.writeI32(argv, argvBuf); + argv += 4; + memory.write(argvBuf, argument); + argvBuf += argument.length; + memory.writeByte(argvBuf, (byte) 0); + argvBuf++; + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int argsSizesGet(Memory memory, int argc, int argvBufSize) { + logger.tracef("args_sizes_get: [%s, %s]", argc, argvBufSize); + int bufSize = arguments.stream().mapToInt(x -> x.length + 1).sum(); + memory.writeI32(argc, arguments.size()); + memory.writeI32(argvBufSize, bufSize); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int clockResGet(Memory memory, int clockId, int resultPtr) { + logger.tracef("clock_res_get: [%s, %s]", clockId, resultPtr); + switch (clockId) { + case WasiClockId.REALTIME: + case WasiClockId.MONOTONIC: + memory.writeLong(resultPtr, 1L); + return wasiResult(WasiErrno.ESUCCESS); + case WasiClockId.PROCESS_CPUTIME_ID: + case WasiClockId.THREAD_CPUTIME_ID: + return wasiResult(WasiErrno.ENOTSUP); + default: + return wasiResult(WasiErrno.EINVAL); + } + } + + //@WasmExport + public int clockTimeGet(Memory memory, int clockId, long precision, int resultPtr) { + logger.tracef("clock_time_get: [%s, %s, %s]", clockId, precision, resultPtr); + switch (clockId) { + case WasiClockId.REALTIME: + case WasiClockId.MONOTONIC: + memory.writeLong(resultPtr, clockTime(clockId)); + return wasiResult(WasiErrno.ESUCCESS); + case WasiClockId.PROCESS_CPUTIME_ID: + case WasiClockId.THREAD_CPUTIME_ID: + return wasiResult(WasiErrno.ENOTSUP); + default: + return wasiResult(WasiErrno.EINVAL); + } + } + + //@WasmExport + public int environGet(Memory memory, int environ, int environBuf) { + logger.tracef("environ_get: [%s, %s]", environ, environBuf); + for (Entry entry : environment) { + byte[] name = entry.getKey(); + byte[] value = entry.getValue(); + byte[] data = new byte[name.length + value.length + 2]; + System.arraycopy(name, 0, data, 0, name.length); + data[name.length] = '='; + System.arraycopy(value, 0, data, name.length + 1, value.length); + data[data.length - 1] = '\0'; + + memory.writeI32(environ, environBuf); + environ += 4; + memory.write(environBuf, data); + environBuf += data.length; + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int environSizesGet(Memory memory, int environCount, int environBufSize) { + logger.tracef("environ_sizes_get: [%s, %s]", environCount, environBufSize); + int bufSize = + environment.stream() + .mapToInt(x -> x.getKey().length + x.getValue().length + 2) + .sum(); + memory.writeI32(environCount, environment.size()); + memory.writeI32(environBufSize, bufSize); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdAdvise(int fd, long offset, long len, int advice) { + logger.tracef("fd_advise: [%s, %s, %s, %s]", fd, offset, len, advice); + + if (len < 0 || offset < 0) { + return wasiResult(WasiErrno.EINVAL); + } + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if ((descriptor instanceof InStream) || (descriptor instanceof OutStream)) { + return wasiResult(WasiErrno.ESPIPE); + } + if (descriptor instanceof Directory) { + return wasiResult(WasiErrno.EISDIR); + } + if (!(descriptor instanceof OpenFile)) { + throw unhandledDescriptor(descriptor); + } + + // do nothing: advise is optional, and Java does not support it + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdAllocate(int fd, long offset, long len) { + logger.tracef("fd_allocate: [%s, %s, %s]", fd, offset, len); + + if (len <= 0 || offset < 0) { + return wasiResult(WasiErrno.EINVAL); + } + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if ((descriptor instanceof InStream) || (descriptor instanceof OutStream)) { + return wasiResult(WasiErrno.EINVAL); + } + if (descriptor instanceof Directory) { + return wasiResult(WasiErrno.EISDIR); + } + if (!(descriptor instanceof OpenFile)) { + throw unhandledDescriptor(descriptor); + } + + var channel = ((OpenFile) descriptor).channel(); + try { + long size = offset + len; + if (size > channel.size()) { + long position = channel.position(); + try { + channel.position(size - 1); + if (channel.write(ByteBuffer.wrap(new byte[1])) != 1) { + return wasiResult(WasiErrno.EIO); + } + } finally { + channel.position(position); + } + } + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdClose(int fd) { + logger.tracef("fd_close: [%s]", fd); + Descriptor descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + descriptors.free(fd); + try { + if (descriptor instanceof Closeable) { + ((Closeable) descriptor).close(); + } + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdDatasync(int fd) { + logger.tracef("fd_datasync: [%s]", fd); + return wasiResult(fileSync(fd, false)); + } + + //@WasmExport + public int fdFdstatGet(Memory memory, int fd, int buf) { + logger.tracef("fd_fdstat_get: [%s, %s]", fd, buf); + int flags = 0; + long rightsBase; + long rightsInheriting = 0; + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + WasiFileType fileType; + if (descriptor instanceof InStream) { + fileType = WasiFileType.CHARACTER_DEVICE; + rightsBase = WasiRights.FD_READ; + } else if (descriptor instanceof OutStream) { + fileType = WasiFileType.CHARACTER_DEVICE; + rightsBase = WasiRights.FD_WRITE; + } else if (descriptor instanceof Directory) { + fileType = WasiFileType.DIRECTORY; + rightsBase = WasiRights.DIRECTORY_RIGHTS_BASE; + rightsInheriting = rightsBase | WasiRights.FILE_RIGHTS_BASE; + } else if (descriptor instanceof OpenFile) { + var file = (OpenFile) descriptor; + fileType = WasiFileType.REGULAR_FILE; + rightsBase = file.rights() & WasiRights.FILE_RIGHTS_BASE; + flags = file.fdFlags(); + } else { + throw unhandledDescriptor(descriptor); + } + + memory.write(buf, new byte[8]); + memory.writeByte(buf, (byte) fileType.value()); + memory.writeShort(buf + 2, (short) flags); + memory.writeLong(buf + 8, rightsBase); + memory.writeLong(buf + 16, rightsInheriting); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdFdstatSetFlags(int fd, int flags) { + logger.tracef("fd_fdstat_set_flags: [%s, %s]", fd, flags); + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if ((descriptor instanceof InStream) || (descriptor instanceof OutStream)) { + return wasiResult(WasiErrno.EINVAL); + } + if ((descriptor instanceof OpenDirectory) || (descriptor instanceof PreopenedDirectory)) { + return wasiResult(WasiErrno.ESUCCESS); + } + if (!(descriptor instanceof OpenFile)) { + throw unhandledDescriptor(descriptor); + } + + // we don't support changing flags + if (flags != ((OpenFile) descriptor).fdFlags()) { + return wasiResult(WasiErrno.ENOTSUP); + } + + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdFdstatSetRights(int fd, long rightsBase, long rightsInheriting) { + logger.errorf( + "fd_fdstat_set_rights operation not supported: [%s, %s, %s]", + fd, rightsBase, rightsInheriting); + return wasiResult(WasiErrno.ENOTSUP); + } + + //@WasmExport + public int fdFilestatGet(Memory memory, int fd, int buf) { + logger.tracef("fd_filestat_get: [%s, %s]", fd, buf); + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if ((descriptor instanceof InStream) || (descriptor instanceof OutStream)) { + Map attributes = + Map.of( + "dev", 0L, + "ino", 0L, + "nlink", 1L, + "size", 0L, + "lastAccessTime", FileTime.from(Instant.EPOCH), + "lastModifiedTime", FileTime.from(Instant.EPOCH), + "ctime", FileTime.from(Instant.EPOCH)); + writeFileStat(memory, buf, attributes, WasiFileType.CHARACTER_DEVICE); + return wasiResult(WasiErrno.ESUCCESS); + } + + Path path; + if (descriptor instanceof OpenFile) { + path = ((OpenFile) descriptor).path(); + } else if (descriptor instanceof OpenDirectory) { + path = ((OpenDirectory) descriptor).path(); + } else { + throw unhandledDescriptor(descriptor); + } + + Map attributes; + try { + attributes = Files.readAttributes(path, "unix:*"); + } catch (UnsupportedOperationException e) { + return wasiResult(WasiErrno.ENOTSUP); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + + writeFileStat(memory, buf, attributes, getFileType(attributes)); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdFilestatSetSize(int fd, long size) { + logger.tracef("fd_filestat_set_size: [%s, %s]", fd, size); + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if ((descriptor instanceof InStream) || (descriptor instanceof OutStream)) { + return wasiResult(WasiErrno.EINVAL); + } + if (descriptor instanceof Directory) { + return wasiResult(WasiErrno.EISDIR); + } + if (!(descriptor instanceof OpenFile)) { + throw unhandledDescriptor(descriptor); + } + + SeekableByteChannel channel = ((OpenFile) descriptor).channel(); + try { + long position = channel.position(); + try { + if (size <= channel.size()) { + channel.truncate(size); + } else { + channel.position(size - 1); + if (channel.write(ByteBuffer.wrap(new byte[1])) != 1) { + return wasiResult(WasiErrno.EIO); + } + } + } finally { + channel.position(position); + } + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdFilestatSetTimes(int fd, long accessTime, long modifiedTime, int fstFlags) { + logger.tracef( + "fd_filestat_set_times: [%s, %s, %s, %s]", fd, accessTime, modifiedTime, fstFlags); + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if ((descriptor instanceof InStream) || (descriptor instanceof OutStream)) { + return wasiResult(WasiErrno.EINVAL); + } + + Path path; + if (descriptor instanceof OpenFile) { + path = ((OpenFile) descriptor).path(); + } else if (descriptor instanceof Directory) { + path = ((Directory) descriptor).path(); + } else { + throw unhandledDescriptor(descriptor); + } + + return wasiResult(setFileTimes(path, modifiedTime, accessTime, fstFlags)); + } + + //@WasmExport + public int fdPread(Memory memory, int fd, int iovs, int iovsLen, long offset, int nreadPtr) { + logger.tracef("fd_pread: [%s, %s, %s, %s, %s]", fd, iovs, iovsLen, offset, nreadPtr); + + if (offset < 0) { + return wasiResult(WasiErrno.EINVAL); + } + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (descriptor instanceof InStream) { + return wasiResult(WasiErrno.ESPIPE); + } + if (descriptor instanceof OutStream) { + return wasiResult(WasiErrno.EBADF); + } + if (descriptor instanceof Directory) { + return wasiResult(WasiErrno.EISDIR); + } + if (!(descriptor instanceof OpenFile)) { + throw unhandledDescriptor(descriptor); + } + var file = (OpenFile) descriptor; + + int totalRead = 0; + for (var i = 0; i < iovsLen; i++) { + int base = iovs + (i * 8); + int iovBase = memory.readInt(base); + var iovLen = memory.readInt(base + 4); + try { + byte[] data = new byte[iovLen]; + int read = file.read(data, offset); + if (read < 0) { + break; + } + memory.write(iovBase, data, 0, read); + offset += read; + totalRead += read; + if (read < iovLen) { + break; + } + } catch (NonReadableChannelException e) { + return wasiResult(WasiErrno.ENOTCAPABLE); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + } + + memory.writeI32(nreadPtr, totalRead); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdPrestatDirName(Memory memory, int fd, int path, int pathLen) { + logger.tracef("fd_prestat_dir_name: [%s, %s, %s]", fd, path, pathLen); + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (!(descriptor instanceof PreopenedDirectory)) { + return wasiResult(WasiErrno.EBADF); + } + byte[] name = ((PreopenedDirectory) descriptor).name(); + + if (pathLen < name.length) { + return wasiResult(WasiErrno.ENAMETOOLONG); + } + + memory.write(path, name); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdPrestatGet(Memory memory, int fd, int buf) { + logger.tracef("fd_prestat_get: [%s, %s]", fd, buf); + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (!(descriptor instanceof PreopenedDirectory)) { + return wasiResult(WasiErrno.EBADF); + } + int length = ((PreopenedDirectory) descriptor).name().length; + + memory.writeI32(buf, 0); // preopentype::dir + memory.writeI32(buf + 4, length); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdPwrite( + Memory memory, int fd, int iovs, int iovsLen, long offset, int nwrittenPtr) { + logger.tracef("fd_pwrite: [%s, %s, %s, %s, %s]", fd, iovs, iovsLen, offset, nwrittenPtr); + + if (offset < 0) { + return wasiResult(WasiErrno.EINVAL); + } + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (descriptor instanceof InStream) { + return wasiResult(WasiErrno.EBADF); + } + if (descriptor instanceof OutStream) { + return wasiResult(WasiErrno.ESPIPE); + } + if (descriptor instanceof Directory) { + return wasiResult(WasiErrno.EISDIR); + } + + if (!(descriptor instanceof OpenFile)) { + throw unhandledDescriptor(descriptor); + } + var file = (OpenFile) descriptor; + + if (flagSet(file.fdFlags(), WasiFdFlags.APPEND)) { + return wasiResult(WasiErrno.ENOTSUP); + } + + var totalWritten = 0; + for (var i = 0; i < iovsLen; i++) { + var base = iovs + (i * 8); + var iovBase = memory.readInt(base); + var iovLen = memory.readInt(base + 4); + var data = memory.readBytes(iovBase, iovLen); + try { + int written = file.write(data, offset); + offset += written; + totalWritten += written; + if (written < iovLen) { + break; + } + } catch (NonWritableChannelException e) { + return wasiResult(WasiErrno.ENOTCAPABLE); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + } + + memory.writeI32(nwrittenPtr, totalWritten); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdRead(Memory memory, int fd, int iovs, int iovsLen, int nreadPtr) { + logger.tracef("fd_read: [%s, %s, %s, %s]", fd, iovs, iovsLen, nreadPtr); + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (descriptor instanceof OutStream) { + return wasiResult(WasiErrno.EBADF); + } + if (descriptor instanceof Directory) { + return wasiResult(WasiErrno.EISDIR); + } + if (!(descriptor instanceof DataReader)) { + throw unhandledDescriptor(descriptor); + } + DataReader reader = (DataReader) descriptor; + + int totalRead = 0; + for (var i = 0; i < iovsLen; i++) { + int base = iovs + (i * 8); + int iovBase = memory.readInt(base); + var iovLen = memory.readInt(base + 4); + try { + byte[] data = new byte[iovLen]; + int read = reader.read(data); + if (read < 0) { + break; + } + memory.write(iovBase, data, 0, read); + totalRead += read; + if (read < iovLen) { + break; + } + } catch (NonReadableChannelException e) { + return wasiResult(WasiErrno.ENOTCAPABLE); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + } + + memory.writeI32(nreadPtr, totalRead); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdReaddir( + Memory memory, int dirFd, int buf, int bufLen, long cookie, int bufUsedPtr) { + logger.tracef("fd_readdir: [%s, %s, %s, %s, %s]", dirFd, buf, bufLen, cookie, bufUsedPtr); + if (cookie < 0) { + return wasiResult(WasiErrno.EINVAL); + } + + var descriptor = descriptors.get(dirFd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (!(descriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path directory = ((Directory) descriptor).path(); + + int used = 0; + try (Stream stream = Files.list(directory)) { + Stream special = Stream.of(directory.resolve("."), directory.resolve("..")); + Iterator iterator = Stream.concat(special, stream).skip(cookie).iterator(); + while (iterator.hasNext()) { + Path entryPath = iterator.next(); + byte[] name = entryPath.getFileName().toString().getBytes(UTF_8); + cookie++; + + Map attributes; + try { + attributes = Files.readAttributes(entryPath, "unix:*"); + } catch (UnsupportedOperationException e) { + return wasiResult(WasiErrno.ENOTSUP); + } catch (NoSuchFileException e) { + continue; + } + + ByteBuffer entry = + ByteBuffer.allocate(24 + name.length).order(ByteOrder.LITTLE_ENDIAN); + entry.putLong(0, cookie); + entry.putLong(8, ((Number) attributes.get("ino")).longValue()); + entry.putInt(16, name.length); + entry.put(20, (byte) getFileType(attributes).value()); + entry.position(24); + entry.put(name); + + int writeSize = min(entry.capacity(), bufLen - used); + memory.write(buf + used, entry.array(), 0, writeSize); + used += writeSize; + + if (used == bufLen) { + break; + } + } + } catch (NotDirectoryException e) { + return wasiResult(WasiErrno.ENOTDIR); + } catch (NoSuchFileException e) { + return wasiResult(WasiErrno.ENOENT); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + + memory.writeI32(bufUsedPtr, used); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdRenumber(int from, int to) { + logger.tracef("fd_renumber: [%s, %s]", from, to); + + var fromDescriptor = descriptors.get(from); + if (fromDescriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (from == to) { + return wasiResult(WasiErrno.ESUCCESS); + } + + var toDescriptor = descriptors.get(to); + if (toDescriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + try { + if (toDescriptor instanceof Closeable) { + ((Closeable) toDescriptor).close(); + } + } catch (IOException e) { + // ignored + } + + descriptors.free(from); + descriptors.set(to, fromDescriptor); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdSeek(Memory memory, int fd, long offset, int whence, int newOffsetPtr) { + logger.tracef("fd_seek: [%s, %s, %s, %s]", fd, offset, whence, newOffsetPtr); + if (whence < 0 || whence > 2) { + return wasiResult(WasiErrno.EINVAL); + } + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if ((descriptor instanceof InStream) || (descriptor instanceof OutStream)) { + return wasiResult(WasiErrno.ESPIPE); + } + if (descriptor instanceof Directory) { + return wasiResult(WasiErrno.EISDIR); + } + if (!(descriptor instanceof OpenFile)) { + throw unhandledDescriptor(descriptor); + } + SeekableByteChannel channel = ((OpenFile) descriptor).channel(); + + long newOffset; + try { + switch (whence) { + case WasiWhence.SET: + channel.position(offset); + break; + case WasiWhence.CUR: + channel.position(channel.position() + offset); + break; + case WasiWhence.END: + channel.position(channel.size() + offset); + break; + } + newOffset = channel.position(); + } catch (IllegalArgumentException e) { + return wasiResult(WasiErrno.EINVAL); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + + memory.writeLong(newOffsetPtr, newOffset); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdSync(int fd) { + logger.tracef("fd_sync: [%s]", fd); + return wasiResult(fileSync(fd, true)); + } + + //@WasmExport + public int fdTell(Memory memory, int fd, int offsetPtr) { + logger.tracef("fd_tell: [%s, %s]", fd, offsetPtr); + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if ((descriptor instanceof InStream) || (descriptor instanceof OutStream)) { + return wasiResult(WasiErrno.ESPIPE); + } + if (descriptor instanceof Directory) { + return wasiResult(WasiErrno.EISDIR); + } + if (!(descriptor instanceof OpenFile)) { + throw unhandledDescriptor(descriptor); + } + SeekableByteChannel channel = ((OpenFile) descriptor).channel(); + + long offset; + try { + offset = channel.position(); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + + memory.writeLong(offsetPtr, offset); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int fdWrite(Memory memory, int fd, int iovs, int iovsLen, int nwrittenPtr) { + logger.tracef("fd_write: [%s, %s, %s, %s]", fd, iovs, iovsLen, nwrittenPtr); + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (descriptor instanceof InStream) { + return wasiResult(WasiErrno.EBADF); + } + if (descriptor instanceof Directory) { + return wasiResult(WasiErrno.EISDIR); + } + if (!(descriptor instanceof DataWriter)) { + throw unhandledDescriptor(descriptor); + } + DataWriter writer = (DataWriter) descriptor; + + var totalWritten = 0; + for (var i = 0; i < iovsLen; i++) { + var base = iovs + (i * 8); + var iovBase = memory.readInt(base); + var iovLen = memory.readInt(base + 4); + var data = memory.readBytes(iovBase, iovLen); + try { + int written = writer.write(data); + totalWritten += written; + if (written < iovLen) { + break; + } + } catch (NonWritableChannelException e) { + return wasiResult(WasiErrno.ENOTCAPABLE); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + } + + memory.writeI32(nwrittenPtr, totalWritten); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int pathCreateDirectory(int dirFd, // @Buffer + String rawPath) { + logger.tracef("path_create_directory: [%s, \"%s\"]", dirFd, rawPath); + var descriptor = descriptors.get(dirFd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (!(descriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path directory = ((Directory) descriptor).path(); + + Path path = resolvePath(directory, rawPath); + if (path == null) { + return wasiResult(WasiErrno.EACCES); + } + + try { + Files.createDirectory(path); + } catch (FileAlreadyExistsException e) { + return wasiResult(WasiErrno.EEXIST); + } catch (NoSuchFileException e) { + return wasiResult(WasiErrno.ENOENT); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int pathFilestatGet( + Memory memory, int dirFd, int lookupFlags, // @Buffer + String rawPath, int buf) { + logger.tracef("path_filestat_get: [%s, %s, \"%s\", %s]", dirFd, lookupFlags, rawPath, buf); + var descriptor = descriptors.get(dirFd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (!(descriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path directory = ((Directory) descriptor).path(); + + Path path = resolvePath(directory, rawPath); + if (path == null) { + return wasiResult(WasiErrno.EACCES); + } + + LinkOption[] linkOptions = toLinkOptions(lookupFlags); + + Map attributes; + try { + if (flagSet(lookupFlags, WasiLookupFlags.SYMLINK_FOLLOW)) { + var resolved = resolveSymlinks(path); + if (resolved.isError()) { + return resolved.error(); + } else { + path = resolved.resolved(); + } + } + attributes = Files.readAttributes(path, "unix:*", linkOptions); + } catch (UnsupportedOperationException e) { + return wasiResult(WasiErrno.ENOTSUP); + } catch (NoSuchFileException e) { + return wasiResult(WasiErrno.ENOENT); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + + writeFileStat(memory, buf, attributes, getFileType(attributes)); + + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int pathFilestatSetTimes( + int fd, + int lookupFlags, + // @Buffer + String rawPath, + long accessTime, + long modifiedTime, + int fstFlags) { + logger.tracef( + "path_filestat_set_times: [%s, %s, \"%s\", %s, %s, %s]", + fd, lookupFlags, rawPath, accessTime, modifiedTime, fstFlags); + + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (!(descriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path directory = ((Directory) descriptor).path(); + + Path path = resolvePath(directory, rawPath); + if (path == null) { + return wasiResult(WasiErrno.EACCES); + } + + return wasiResult(setFileTimes(path, modifiedTime, accessTime, fstFlags)); + } + + private static final class ResolvedSymlink { + private final Path resolved; + private final int errorcode; + + ResolvedSymlink(Path resolved) { + this.resolved = resolved; + this.errorcode = 0; + } + + ResolvedSymlink(int errcode) { + this.resolved = null; + this.errorcode = errcode; + } + + boolean isError() { + return (this.resolved == null); + } + + int error() { + return errorcode; + } + + Path resolved() { + return resolved; + } + } + + private ResolvedSymlink resolveSymlinks(Path path) { + List visited = new ArrayList<>(); + while (Files.isSymbolicLink(path)) { + if (visited.contains(path)) { + return new ResolvedSymlink(wasiResult(WasiErrno.ELOOP)); + } else { + visited.add(path); + } + + try { + path = Files.readSymbolicLink(path); + } catch (IOException e) { + return new ResolvedSymlink(wasiResult(WasiErrno.EIO)); + } + } + + return new ResolvedSymlink(path); + } + + //@WasmExport + public int pathLink( + int oldFd, + int oldFlags, + // @Buffer + String rawOldPath, + int newFd, + // @Buffer + String rawNewPath) { + logger.tracef( + "path_link: [%s, %s, \"%s\", %s, \"%s\"]", + oldFd, oldFlags, rawOldPath, newFd, rawNewPath); + var oldDescriptor = descriptors.get(oldFd); + if (oldDescriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + if (!(oldDescriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path oldDirectory = ((Directory) oldDescriptor).path(); + + var newDescriptor = descriptors.get(newFd); + if (newDescriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + if (!(newDescriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path newDirectory = ((Directory) newDescriptor).path(); + + Path oldPath = resolvePath(oldDirectory, rawOldPath); + if (oldPath == null) { + return wasiResult(WasiErrno.EACCES); + } + + if (rawNewPath.endsWith("/")) { + return wasiResult(WasiErrno.ENOENT); + } + Path newPath = resolvePath(newDirectory, rawNewPath); + if (newPath == null) { + return wasiResult(WasiErrno.EACCES); + } + if (Files.exists(newPath)) { + return wasiResult(WasiErrno.EEXIST); + } + if (Files.isDirectory(oldPath)) { + return wasiResult(WasiErrno.EACCES); + } + + if (Files.isDirectory(oldPath) && Files.isRegularFile(newPath, LinkOption.NOFOLLOW_LINKS)) { + return wasiResult(WasiErrno.ENOTDIR); + } + if (Files.isRegularFile(oldPath, LinkOption.NOFOLLOW_LINKS) && Files.isDirectory(newPath)) { + return wasiResult(WasiErrno.EISDIR); + } + + try { + if (flagSet(oldFlags, WasiLookupFlags.SYMLINK_FOLLOW)) { + var resolved = resolveSymlinks(oldPath); + if (resolved.isError()) { + return resolved.error(); + } else { + oldPath = resolved.resolved(); + } + } + Files.createLink(newPath, oldPath); + } catch (UnsupportedOperationException | AtomicMoveNotSupportedException e) { + return wasiResult(WasiErrno.ENOTSUP); + } catch (NoSuchFileException e) { + return wasiResult(WasiErrno.ENOENT); + } catch (DirectoryNotEmptyException e) { + return wasiResult(WasiErrno.ENOTEMPTY); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int pathOpen( + Memory memory, + int dirFd, + int lookupFlags, + // @Buffer + String rawPath, + int openFlags, + long rightsBase, + long rightsInheriting, + int fdFlags, + int fdPtr) { + logger.tracef( + "path_open: [%s, %s, \"%s\", %s, %s, %s, %s, %s]", + dirFd, + lookupFlags, + rawPath, + openFlags, + rightsBase, + rightsInheriting, + fdFlags, + fdPtr); + var descriptor = descriptors.get(dirFd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (!(descriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path directory = ((Directory) descriptor).path(); + + if (rawPath.endsWith("\0")) { + return wasiResult(WasiErrno.EINVAL); + } + + Path path = resolvePath(directory, rawPath); + if (path == null) { + return wasiResult(WasiErrno.EPERM); + } + + if (flagSet(openFlags, WasiOpenFlags.DIRECTORY) + && !flagSet(lookupFlags, WasiLookupFlags.SYMLINK_FOLLOW) + && Files.isSymbolicLink(path)) { + return wasiResult(WasiErrno.ENOTDIR); + } + + if (!flagSet(lookupFlags, WasiLookupFlags.SYMLINK_FOLLOW) && Files.isSymbolicLink(path)) { + return wasiResult(WasiErrno.ELOOP); + } + + if (flagSet(lookupFlags, WasiLookupFlags.SYMLINK_FOLLOW)) { + var resolved = resolveSymlinks(path); + if (resolved.isError()) { + return resolved.error(); + } else { + path = resolved.resolved(); + } + } + + if (Files.isDirectory(path)) { + if (flagSet(rightsBase, WasiRights.FD_WRITE)) { + return wasiResult(WasiErrno.EISDIR); + } + int fd = descriptors.allocate(new OpenDirectory(path)); + memory.writeI32(fdPtr, fd); + return wasiResult(WasiErrno.ESUCCESS); + } + + if (rawPath.endsWith("/")) { + return wasiResult(WasiErrno.ENOTDIR); + } + if (flagSet(openFlags, WasiOpenFlags.DIRECTORY) && Files.exists(path)) { + return wasiResult(WasiErrno.ENOTDIR); + } + + Set openOptions = new HashSet<>(List.of()); + + boolean append = flagSet(fdFlags, WasiFdFlags.APPEND); + boolean truncate = flagSet(openFlags, WasiOpenFlags.TRUNC); + + if (append && truncate) { + return wasiResult(WasiErrno.ENOTSUP); + } + if (!append && flagSet(rightsBase, WasiRights.FD_READ)) { + openOptions.add(StandardOpenOption.READ); + } + if (flagSet(rightsBase, WasiRights.FD_WRITE)) { + openOptions.add(StandardOpenOption.WRITE); + } + + if (flagSet(openFlags, WasiOpenFlags.CREAT)) { + if (flagSet(openFlags, WasiOpenFlags.EXCL)) { + openOptions.add(StandardOpenOption.CREATE_NEW); + } else { + openOptions.add(StandardOpenOption.CREATE); + } + openOptions.add(StandardOpenOption.WRITE); + } + if (truncate) { + openOptions.add(StandardOpenOption.TRUNCATE_EXISTING); + } + if (append) { + openOptions.add(StandardOpenOption.APPEND); + } + if (flagSet(fdFlags, WasiFdFlags.SYNC)) { + openOptions.add(StandardOpenOption.SYNC); + } + if (flagSet(fdFlags, WasiFdFlags.DSYNC)) { + openOptions.add(StandardOpenOption.DSYNC); + } + // ignore WasiFdFlags.RSYNC and WasiFdFlags.NONBLOCK + + int fd; + try { + FileChannel channel = FileChannel.open(path, openOptions); + fd = descriptors.allocate(new OpenFile(path, channel, fdFlags, rightsBase)); + } catch (FileAlreadyExistsException e) { + return wasiResult(WasiErrno.EEXIST); + } catch (NoSuchFileException e) { + return wasiResult(WasiErrno.ENOENT); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + + memory.writeI32(fdPtr, fd); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int pathReadlink( + Memory memory, int dirFd, // @Buffer + String rawPath, int buf, int bufLen, int bufUsedPtr) { + logger.tracef( + "path_readlink: [%s, \"%s\", %s, %s, %s]", dirFd, rawPath, buf, bufLen, bufUsedPtr); + + var descriptor = descriptors.get(dirFd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (!(descriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path directory = ((Directory) descriptor).path(); + + Path path = resolvePath(directory, rawPath); + if (path == null) { + return wasiResult(WasiErrno.EACCES); + } + + Path link; + try { + link = Files.readSymbolicLink(path); + } catch (UnsupportedOperationException e) { + return wasiResult(WasiErrno.ENOTSUP); + } catch (NotLinkException e) { + return wasiResult(WasiErrno.EINVAL); + } catch (NoSuchFileException e) { + return wasiResult(WasiErrno.ENOENT); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + + byte[] name = link.getFileName().toString().getBytes(UTF_8); + int used = min(name.length, bufLen); + memory.write(buf, name, 0, used); + memory.writeI32(bufUsedPtr, used); + + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int pathRemoveDirectory(int dirFd, // @Buffer + String rawPath) { + logger.tracef("path_remove_directory: [%s, \"%s\"]", dirFd, rawPath); + var descriptor = descriptors.get(dirFd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (!(descriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path directory = ((Directory) descriptor).path(); + + Path path = resolvePath(directory, rawPath); + if (path == null) { + return wasiResult(WasiErrno.EACCES); + } + + try { + var attributes = + Files.readAttributes( + path, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS); + if (!attributes.isDirectory()) { + return wasiResult(WasiErrno.ENOTDIR); + } + Files.delete(path); + } catch (NoSuchFileException e) { + return wasiResult(WasiErrno.ENOENT); + } catch (DirectoryNotEmptyException e) { + return wasiResult(WasiErrno.ENOTEMPTY); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int pathRename( + int oldFd, // @Buffer + String oldRawPath, int newFd, // @Buffer + String newRawPath) { + logger.tracef( + "path_rename: [%s, \"%s\", %s, \"%s\"]", oldFd, oldRawPath, newFd, newRawPath); + var oldDescriptor = descriptors.get(oldFd); + if (oldDescriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + if (!(oldDescriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path oldDirectory = ((Directory) oldDescriptor).path(); + + var newDescriptor = descriptors.get(newFd); + if (newDescriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + if (!(newDescriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path newDirectory = ((Directory) newDescriptor).path(); + + Path oldPath = resolvePath(oldDirectory, oldRawPath); + if (oldPath == null) { + return wasiResult(WasiErrno.EACCES); + } + + Path newPath = resolvePath(newDirectory, newRawPath); + if (newPath == null) { + return wasiResult(WasiErrno.EACCES); + } + + if (Files.isDirectory(oldPath) && Files.isRegularFile(newPath, LinkOption.NOFOLLOW_LINKS)) { + return wasiResult(WasiErrno.ENOTDIR); + } + if (Files.isRegularFile(oldPath, LinkOption.NOFOLLOW_LINKS) && Files.isDirectory(newPath)) { + return wasiResult(WasiErrno.EISDIR); + } + + try { + Files.move( + oldPath, + newPath, + StandardCopyOption.REPLACE_EXISTING, + StandardCopyOption.ATOMIC_MOVE, + StandardCopyOption.COPY_ATTRIBUTES); + } catch (UnsupportedOperationException | AtomicMoveNotSupportedException e) { + return wasiResult(WasiErrno.ENOTSUP); + } catch (NoSuchFileException e) { + return wasiResult(WasiErrno.ENOENT); + } catch (DirectoryNotEmptyException e) { + return wasiResult(WasiErrno.ENOTEMPTY); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int pathSymlink(// @Buffer + String oldRawPath, int dirFd, // @Buffer + String newRawPath) { + logger.tracef("path_symlink: [\"%s\", %s, \"%s\"]", oldRawPath, dirFd, newRawPath); + var descriptor = descriptors.get(dirFd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + if (!(descriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path directory = ((Directory) descriptor).path(); + + Path oldPath = resolvePath(directory, oldRawPath); + if (oldPath == null) { + return wasiResult(WasiErrno.EACCES); + } + + if (newRawPath.endsWith("/")) { + return wasiResult(WasiErrno.EEXIST); + } + + Path newPath = resolvePath(directory, newRawPath); + if (newPath == null) { + return wasiResult(WasiErrno.EACCES); + } + + if (Files.exists(newPath)) { + return wasiResult(WasiErrno.EEXIST); + } + + if (Files.isDirectory(oldPath) && Files.isRegularFile(newPath, LinkOption.NOFOLLOW_LINKS)) { + return wasiResult(WasiErrno.ENOTDIR); + } + if (Files.isRegularFile(oldPath, LinkOption.NOFOLLOW_LINKS) && Files.isDirectory(newPath)) { + return wasiResult(WasiErrno.EISDIR); + } + + try { + Files.createSymbolicLink(newPath, oldPath); + } catch (UnsupportedOperationException | AtomicMoveNotSupportedException e) { + return wasiResult(WasiErrno.ENOTSUP); + } catch (NoSuchFileException e) { + return wasiResult(WasiErrno.ENOENT); + } catch (DirectoryNotEmptyException e) { + return wasiResult(WasiErrno.ENOTEMPTY); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int pathUnlinkFile(int dirFd, // @Buffer + String rawPath) { + logger.tracef("path_unlink_file: [%s, \"%s\"]", dirFd, rawPath); + var descriptor = descriptors.get(dirFd); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + + if (!(descriptor instanceof Directory)) { + return wasiResult(WasiErrno.ENOTDIR); + } + Path directory = ((Directory) descriptor).path(); + + Path path = resolvePath(directory, rawPath); + if (path == null) { + return wasiResult(WasiErrno.EACCES); + } + + try { + var attributes = + Files.readAttributes( + path, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS); + if (attributes.isDirectory()) { + return wasiResult(WasiErrno.EISDIR); + } + if (rawPath.endsWith("/")) { + return wasiResult(WasiErrno.ENOTDIR); + } + Files.delete(path); + } catch (NoSuchFileException e) { + return wasiResult(WasiErrno.ENOENT); + } catch (IOException e) { + return wasiResult(WasiErrno.EIO); + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int pollOneoff( + Memory memory, int inPtr, int outPtr, int nsubscriptions, int neventsPtr) { + logger.tracef("poll_oneoff: [%s, %s, %s, %s]", inPtr, outPtr, nsubscriptions, neventsPtr); + if (nsubscriptions <= 0) { + return wasiResult(WasiErrno.EINVAL); + } + + int nevents = 0; + List> clockSubs = new ArrayList<>(); + List> readSubs = new ArrayList<>(); + + // collect clock and read subscriptions + for (int i = 0; i < nsubscriptions; i++) { + long userData = memory.readLong(inPtr); + byte eventType = memory.read(inPtr + 8); + inPtr += 16; + switch (eventType) { + case WasiEventType.CLOCK: + int clockId = memory.readInt(inPtr); + long timeout = memory.readLong(inPtr + 8); + short flags = memory.readShort(inPtr + 24); + if (clockId != WasiClockId.REALTIME && clockId != WasiClockId.MONOTONIC) { + return wasiResult(WasiErrno.EINVAL); + } + if (flagSet(flags, WasiSubClockFlags.SUBSCRIPTION_CLOCK_ABSTIME)) { + timeout -= clockTime(clockId); + } + clockSubs.add(Map.entry(timeout, userData)); + break; + case WasiEventType.FD_READ: + case WasiEventType.FD_WRITE: + int fd = memory.readInt(inPtr); + if (fd < 0) { + return wasiResult(WasiErrno.EBADF); + } + var descriptor = descriptors.get(fd); + if (descriptor instanceof InStream && eventType == WasiEventType.FD_READ) { + readSubs.add(Map.entry((InStream) descriptor, userData)); + } else if (descriptor instanceof OutStream + && eventType == WasiEventType.FD_WRITE) { + // assume output streams are always writable + writeEvent(memory, outPtr, userData, eventType, WasiErrno.ESUCCESS); + outPtr += 32; + nevents++; + } else { + WasiErrno errno; + if (descriptor == null) { + errno = WasiErrno.EBADF; + } else if (descriptor instanceof OpenFile) { + // per specification: this event always triggers for regular files + errno = WasiErrno.ESUCCESS; + } else { + errno = WasiErrno.ENOTSUP; + } + writeEvent(memory, outPtr, userData, eventType, errno); + outPtr += 32; + nevents++; + } + break; + default: + return wasiResult(WasiErrno.EINVAL); + } + inPtr += 32; + } + + // sleep until the earliest clock sub, or forever if we only have read subs + long minTimeout = clockSubs.stream().mapToLong(Entry::getKey).min().orElse(Long.MAX_VALUE); + + // loop until at least one event is triggered + long start = System.nanoTime(); + do { + // process available read events + for (var entry : readSubs) { + InStream stream = entry.getKey(); + long userData = entry.getValue(); + try { + int available = stream.available(); + if (available <= 0) { + continue; + } + writeEvent(memory, outPtr, userData, WasiEventType.FD_READ, WasiErrno.ESUCCESS); + memory.writeLong(outPtr + 16, available); + outPtr += 32; + nevents++; + } catch (IOException e) { + writeEvent(memory, outPtr, userData, WasiEventType.FD_READ, WasiErrno.EIO); + outPtr += 32; + nevents++; + } + } + + // sleep if no events have triggered + long elapsed = System.nanoTime() - start; + if (nevents == 0) { + long duration = max(minTimeout, 0) - elapsed; + // poll if we have read subs, rather than waiting for the full clock timeout + if (!readSubs.isEmpty()) { + duration = min(duration, MILLISECONDS.toNanos(100)); + } + try { + NANOSECONDS.sleep(duration); + } catch (InterruptedException e) { + throw new ChicoryException("Thread interrupted", e); + } + } + + // process available clock events + for (var entry : clockSubs) { + long timeout = entry.getKey(); + long userData = entry.getValue(); + if (timeout <= elapsed) { + writeEvent(memory, outPtr, userData, WasiEventType.CLOCK, WasiErrno.ESUCCESS); + outPtr += 32; + nevents++; + } + } + } while (nevents == 0); + + memory.writeI32(neventsPtr, nevents); + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public void procExit(int code) { + logger.tracef("proc_exit: [%s]", code); + throw new WasiExitException(code); + } + + //@WasmExport + public int procRaise(int sig) { + logger.tracef("proc_raise: [%s]", sig); + throw new WasmRuntimeException("We don't yet support this WASI call: proc_raise"); + } + + //@WasmExport + public int randomGet(Memory memory, int buf, int bufLen) { + logger.tracef("random_get: [%s, %s]", buf, bufLen); + if (bufLen < 0) { + return wasiResult(WasiErrno.EINVAL); + } + + byte[] data = new byte[min(bufLen, 4096)]; + int written = 0; + while (written < bufLen) { + if (Thread.currentThread().isInterrupted()) { + throw new ChicoryException("Thread interrupted"); + } + int size = min(data.length, bufLen - written); + if (size < data.length) { + data = new byte[size]; + } + random.nextBytes(data); + memory.write(buf + written, data, 0, size); + written += size; + } + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int schedYield() { + logger.trace("sched_yield"); + // do nothing here + return wasiResult(WasiErrno.ESUCCESS); + } + + //@WasmExport + public int sockAccept(int sock, int fdFlags, int roFdPtr) { + logger.tracef("sock_accept: [%s, %s, %s]", sock, fdFlags, roFdPtr); + throw new WasmRuntimeException("We don't yet support this WASI call: sock_accept"); + } + + //@WasmExport + public int sockRecv( + int sock, int riDataPtr, int riDataLen, int riFlags, int roDataLenPtr, int roFlagsPtr) { + logger.tracef( + "sock_recv: [%s, %s, %s, %s, %s, %s]", + sock, riDataPtr, riDataLen, riFlags, roDataLenPtr, roFlagsPtr); + throw new WasmRuntimeException("We don't yet support this WASI call: sock_recv"); + } + + //@WasmExport + public int sockSend(int sock, int siDataPtr, int siDataLen, int siFlags, int retDataLenPtr) { + logger.tracef( + "sock_send: [%s, %s, %s, %s, %s]", + sock, siDataPtr, siDataLen, siFlags, retDataLenPtr); + throw new WasmRuntimeException("We don't yet support this WASI call: sock_send"); + } + + //@WasmExport + public int sockShutdown(int sock, int how) { + logger.tracef("sock_shutdown: [%s, %s]", sock, how); + Descriptor descriptor = descriptors.get(sock); + if (descriptor == null) { + return wasiResult(WasiErrno.EBADF); + } + // sockets are not supported, so this cannot be a socket + return wasiResult(WasiErrno.ENOTSOCK); + } + + public HostFunction[] toHostFunctions() { + return WasiPreview1_ModuleFactory.toHostFunctions(this); + } + + private int wasiResult(WasiErrno errno) { + if (errno != WasiErrno.ESUCCESS) { + logger.tracef("result = %s", errno.name()); + } + return errno.value(); + } + + private static void writeEvent( + Memory memory, int index, long userData, byte eventType, WasiErrno errno) { + memory.fill((byte) 0, index, index + 32); + memory.writeLong(index, userData); + memory.writeShort(index + 8, (short) errno.value()); + memory.writeByte(index + 10, eventType); + } + + private long clockTime(int clockId) { + switch (clockId) { + case WasiClockId.REALTIME: + Instant now = clock.instant(); + return SECONDS.toNanos(now.getEpochSecond()) + now.getNano(); + case WasiClockId.MONOTONIC: + return System.nanoTime(); + default: + throw new IllegalArgumentException("Invalid clockId: " + clockId); + } + } + + private WasiErrno setFileTimes(Path path, long modifiedTime, long accessTime, int flags) { + boolean modifiedSet = flagSet(flags, WasiFstFlags.MTIM); + boolean modifiedNow = flagSet(flags, WasiFstFlags.MTIM_NOW); + boolean accessSet = flagSet(flags, WasiFstFlags.ATIM); + boolean accessNow = flagSet(flags, WasiFstFlags.ATIM_NOW); + + if ((modifiedSet && modifiedNow) || (accessSet && accessNow)) { + return WasiErrno.EINVAL; + } + + FileTime lastModifiedTime = toFileTime(modifiedTime, modifiedSet, modifiedNow); + FileTime lastAccessTime = toFileTime(accessTime, accessSet, accessNow); + + try { + Files.getFileAttributeView(path, BasicFileAttributeView.class) + .setTimes(lastModifiedTime, lastAccessTime, null); + } catch (IOException e) { + return WasiErrno.EIO; + } + return WasiErrno.ESUCCESS; + } + + private FileTime toFileTime(long time, boolean set, boolean now) { + if (set) { + return FileTime.from(time, NANOSECONDS); + } + if (now) { + return FileTime.from(clock.instant()); + } + return null; + } + + private WasiErrno fileSync(int fd, boolean metadata) { + var descriptor = descriptors.get(fd); + if (descriptor == null) { + return WasiErrno.EBADF; + } + + if ((descriptor instanceof InStream) + || (descriptor instanceof OutStream) + || (descriptor instanceof Directory)) { + return WasiErrno.EINVAL; + } + + if (!(descriptor instanceof OpenFile)) { + throw unhandledDescriptor(descriptor); + } + var channel = ((OpenFile) descriptor).channel(); + + try { + channel.force(metadata); + } catch (IOException e) { + return WasiErrno.EIO; + } + return WasiErrno.ESUCCESS; + } + + private static Path resolvePath(Path directory, String rawPathString) { + Path rawPath; + try { + rawPath = directory.getFileSystem().getPath(rawPathString); + } catch (InvalidPathException e) { + return null; + } + + if (rawPath.isAbsolute()) { + return null; + } + + String normalized = rawPath.normalize().toString(); + if (normalized.equals("..") || normalized.startsWith("../")) { + return null; + } + + return directory.resolve(normalized); + } + + private static void writeFileStat( + Memory memory, int buf, Map attributes, WasiFileType fileType) { + memory.writeLong(buf, (long) attributes.get("dev")); + memory.writeLong(buf + 8, ((Number) attributes.get("ino")).longValue()); + memory.write(buf + 16, new byte[8]); + memory.writeByte(buf + 16, (byte) fileType.value()); + memory.writeLong(buf + 24, ((Number) attributes.get("nlink")).longValue()); + memory.writeLong(buf + 32, (long) attributes.get("size")); + memory.writeLong(buf + 40, fileTimeToNanos(attributes, "lastAccessTime")); + memory.writeLong(buf + 48, fileTimeToNanos(attributes, "lastModifiedTime")); + memory.writeLong(buf + 56, fileTimeToNanos(attributes, "ctime")); + } + + private static long fileTimeToNanos(Map attributes, String name) { + return ((FileTime) attributes.get(name)).to(NANOSECONDS); + } + + private static WasiFileType getFileType(Map attributes) { + if ((boolean) attributes.get("isSymbolicLink")) { + return WasiFileType.SYMBOLIC_LINK; + } + if ((boolean) attributes.get("isDirectory")) { + return WasiFileType.DIRECTORY; + } + if ((boolean) attributes.get("isRegularFile")) { + return WasiFileType.REGULAR_FILE; + } + return WasiFileType.UNKNOWN; + } + + private static LinkOption[] toLinkOptions(int lookupFlags) { + return flagSet(lookupFlags, WasiLookupFlags.SYMLINK_FOLLOW) + ? new LinkOption[0] + : new LinkOption[] {LinkOption.NOFOLLOW_LINKS}; + } + + private static boolean flagSet(long flags, long mask) { + if (Long.bitCount(mask) != 1) { + throw new IllegalArgumentException("mask must be a single bit"); + } + return (flags & mask) != 0; + } + + private static RuntimeException unhandledDescriptor(Descriptor descriptor) { + return new WasmRuntimeException("Unhandled descriptor: " + descriptor.getClass().getName()); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiPreview1_ModuleFactory.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiPreview1_ModuleFactory.java new file mode 100644 index 000000000..a3567860d --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiPreview1_ModuleFactory.java @@ -0,0 +1,645 @@ +package com.dylibso.chicory.wasi; + +import com.dylibso.chicory.runtime.HostFunction; +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.wasm.types.Value; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.ValType; +import java.util.List; +import javax.annotation.processing.Generated; + +@Generated("com.dylibso.chicory.annotations.processor.HostModuleProcessor") +public final class WasiPreview1_ModuleFactory { + + private WasiPreview1_ModuleFactory() { + } + + public static HostFunction[] toHostFunctions(WasiPreview1 functions) { + return toHostFunctions(functions, + "wasi_snapshot_preview1"); + } + + public static HostFunction[] toHostFunctions(WasiPreview1 functions, String moduleName) { + return new HostFunction[] { // + new HostFunction(moduleName, + "adapter_close_badfd", + FunctionType.of(List.of(ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.adapterCloseBadfd((int) args[0]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "adapter_open_badfd", + FunctionType.of(List.of(ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.adapterOpenBadfd((int) args[0]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "args_get", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.argsGet(instance.memory(), + (int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "args_sizes_get", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.argsSizesGet(instance.memory(), + (int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "clock_res_get", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.clockResGet(instance.memory(), + (int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "clock_time_get", + FunctionType.of(List.of(ValType.I32, + ValType.I64, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.clockTimeGet(instance.memory(), + (int) args[0], + args[1], + (int) args[2]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "environ_get", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.environGet(instance.memory(), + (int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "environ_sizes_get", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.environSizesGet(instance.memory(), + (int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_advise", + FunctionType.of(List.of(ValType.I32, + ValType.I64, + ValType.I64, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdAdvise((int) args[0], + args[1], + args[2], + (int) args[3]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_allocate", + FunctionType.of(List.of(ValType.I32, + ValType.I64, + ValType.I64), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdAllocate((int) args[0], + args[1], + args[2]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_close", + FunctionType.of(List.of(ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdClose((int) args[0]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_datasync", + FunctionType.of(List.of(ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdDatasync((int) args[0]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_fdstat_get", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdFdstatGet(instance.memory(), + (int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_fdstat_set_flags", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdFdstatSetFlags((int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_fdstat_set_rights", + FunctionType.of(List.of(ValType.I32, + ValType.I64, + ValType.I64), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdFdstatSetRights((int) args[0], + args[1], + args[2]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_filestat_get", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdFilestatGet(instance.memory(), + (int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_filestat_set_size", + FunctionType.of(List.of(ValType.I32, + ValType.I64), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdFilestatSetSize((int) args[0], + args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_filestat_set_times", + FunctionType.of(List.of(ValType.I32, + ValType.I64, + ValType.I64, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdFilestatSetTimes((int) args[0], + args[1], + args[2], + (int) args[3]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_pread", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I64, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdPread(instance.memory(), + (int) args[0], + (int) args[1], + (int) args[2], + args[3], + (int) args[4]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_prestat_dir_name", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdPrestatDirName(instance.memory(), + (int) args[0], + (int) args[1], + (int) args[2]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_prestat_get", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdPrestatGet(instance.memory(), + (int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_pwrite", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I64, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdPwrite(instance.memory(), + (int) args[0], + (int) args[1], + (int) args[2], + args[3], + (int) args[4]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_read", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdRead(instance.memory(), + (int) args[0], + (int) args[1], + (int) args[2], + (int) args[3]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_readdir", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I64, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdReaddir(instance.memory(), + (int) args[0], + (int) args[1], + (int) args[2], + args[3], + (int) args[4]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_renumber", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdRenumber((int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_seek", + FunctionType.of(List.of(ValType.I32, + ValType.I64, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdSeek(instance.memory(), + (int) args[0], + args[1], + (int) args[2], + (int) args[3]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_sync", + FunctionType.of(List.of(ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdSync((int) args[0]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_tell", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdTell(instance.memory(), + (int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "fd_write", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.fdWrite(instance.memory(), + (int) args[0], + (int) args[1], + (int) args[2], + (int) args[3]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "path_create_directory", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pathCreateDirectory((int) args[0], + instance.memory().readString((int) args[1], + (int) args[2])); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "path_filestat_get", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pathFilestatGet(instance.memory(), + (int) args[0], + (int) args[1], + instance.memory().readString((int) args[2], + (int) args[3]), + (int) args[4]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "path_filestat_set_times", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I64, + ValType.I64, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pathFilestatSetTimes((int) args[0], + (int) args[1], + instance.memory().readString((int) args[2], + (int) args[3]), + args[4], + args[5], + (int) args[6]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "path_link", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pathLink((int) args[0], + (int) args[1], + instance.memory().readString((int) args[2], + (int) args[3]), + (int) args[4], + instance.memory().readString((int) args[5], + (int) args[6])); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "path_open", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I64, + ValType.I64, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pathOpen(instance.memory(), + (int) args[0], + (int) args[1], + instance.memory().readString((int) args[2], + (int) args[3]), + (int) args[4], + args[5], + args[6], + (int) args[7], + (int) args[8]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "path_readlink", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pathReadlink(instance.memory(), + (int) args[0], + instance.memory().readString((int) args[1], + (int) args[2]), + (int) args[3], + (int) args[4], + (int) args[5]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "path_remove_directory", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pathRemoveDirectory((int) args[0], + instance.memory().readString((int) args[1], + (int) args[2])); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "path_rename", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pathRename((int) args[0], + instance.memory().readString((int) args[1], + (int) args[2]), + (int) args[3], + instance.memory().readString((int) args[4], + (int) args[5])); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "path_symlink", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pathSymlink(instance.memory().readString((int) args[0], + (int) args[1]), + (int) args[2], + instance.memory().readString((int) args[3], + (int) args[4])); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "path_unlink_file", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pathUnlinkFile((int) args[0], + instance.memory().readString((int) args[1], + (int) args[2])); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "poll_oneoff", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.pollOneoff(instance.memory(), + (int) args[0], + (int) args[1], + (int) args[2], + (int) args[3]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "proc_exit", + FunctionType.of(List.of(ValType.I32), + List.of()), + (Instance instance, long... args) -> { + functions.procExit((int) args[0]); + return null; + }), // + new HostFunction(moduleName, + "proc_raise", + FunctionType.of(List.of(ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.procRaise((int) args[0]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "random_get", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.randomGet(instance.memory(), + (int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "sched_yield", + FunctionType.of(List.of(), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.schedYield(); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "sock_accept", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.sockAccept((int) args[0], + (int) args[1], + (int) args[2]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "sock_recv", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.sockRecv((int) args[0], + (int) args[1], + (int) args[2], + (int) args[3], + (int) args[4], + (int) args[5]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "sock_send", + FunctionType.of(List.of(ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.sockSend((int) args[0], + (int) args[1], + (int) args[2], + (int) args[3], + (int) args[4]); + return new long[] { (long) result }; + }), // + new HostFunction(moduleName, + "sock_shutdown", + FunctionType.of(List.of(ValType.I32, + ValType.I32), + List.of(ValType.I32)), + (Instance instance, long... args) -> { + int result = functions.sockShutdown((int) args[0], + (int) args[1]); + return new long[] { (long) result }; + }) }; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiRights.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiRights.java new file mode 100644 index 000000000..edf37a057 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiRights.java @@ -0,0 +1,80 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI rights + */ +final class WasiRights { + private WasiRights() {} + + public static final int FD_DATASYNC = bit(0); + public static final int FD_READ = bit(1); + public static final int FD_SEEK = bit(2); + public static final int FD_FDSTAT_SET_FLAGS = bit(3); + public static final int FD_SYNC = bit(4); + public static final int FD_TELL = bit(5); + public static final int FD_WRITE = bit(6); + public static final int FD_ADVISE = bit(7); + public static final int FD_ALLOCATE = bit(8); + public static final int PATH_CREATE_DIRECTORY = bit(9); + public static final int PATH_CREATE_FILE = bit(10); + public static final int PATH_LINK_SOURCE = bit(11); + public static final int PATH_LINK_TARGET = bit(12); + public static final int PATH_OPEN = bit(13); + public static final int FD_READDIR = bit(14); + public static final int PATH_READLINK = bit(15); + public static final int PATH_RENAME_SOURCE = bit(16); + public static final int PATH_RENAME_TARGET = bit(17); + public static final int PATH_FILESTAT_GET = bit(18); + public static final int PATH_FILESTAT_SET_SIZE = bit(19); + public static final int PATH_FILESTAT_SET_TIMES = bit(20); + public static final int FD_FILESTAT_GET = bit(21); + public static final int FD_FILESTAT_SET_SIZE = bit(22); + public static final int FD_FILESTAT_SET_TIMES = bit(23); + public static final int PATH_SYMLINK = bit(24); + public static final int PATH_REMOVE_DIRECTORY = bit(25); + public static final int PATH_UNLINK_FILE = bit(26); + public static final int POLL_FD_READWRITE = bit(27); + public static final int SOCK_SHUTDOWN = bit(28); + public static final int SOCK_ACCEPT = bit(29); + + public static final int FILE_RIGHTS_BASE = + FD_DATASYNC + | FD_READ + | FD_SEEK + | FD_FDSTAT_SET_FLAGS + | FD_SYNC + | FD_TELL + | FD_WRITE + | FD_ADVISE + | FD_ALLOCATE + | FD_FILESTAT_GET + | FD_FILESTAT_SET_SIZE + | FD_FILESTAT_SET_TIMES + | POLL_FD_READWRITE; + + public static final int DIRECTORY_RIGHTS_BASE = + FD_DATASYNC + | FD_FDSTAT_SET_FLAGS + | FD_SYNC + | PATH_CREATE_DIRECTORY + | PATH_CREATE_FILE + | PATH_LINK_SOURCE + | PATH_LINK_TARGET + | PATH_OPEN + | FD_READDIR + | PATH_READLINK + | PATH_RENAME_SOURCE + | PATH_RENAME_TARGET + | PATH_FILESTAT_GET + | PATH_FILESTAT_SET_SIZE + | PATH_FILESTAT_SET_TIMES + | FD_FILESTAT_GET + | FD_FILESTAT_SET_TIMES + | PATH_SYMLINK + | PATH_REMOVE_DIRECTORY + | PATH_UNLINK_FILE; + + private static int bit(int n) { + return 1 << n; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiSubClockFlags.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiSubClockFlags.java new file mode 100644 index 000000000..8c0d6b547 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiSubClockFlags.java @@ -0,0 +1,10 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI subclockflags flags + */ +final class WasiSubClockFlags { + private WasiSubClockFlags() {} + + public static final int SUBSCRIPTION_CLOCK_ABSTIME = 1; +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiWhence.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiWhence.java new file mode 100644 index 000000000..4306f1631 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasi/WasiWhence.java @@ -0,0 +1,12 @@ +package com.dylibso.chicory.wasi; + +/** + * WASI whence + */ +final class WasiWhence { + private WasiWhence() {} + + public static final int SET = 0; + public static final int CUR = 1; + public static final int END = 2; +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/ChicoryException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/ChicoryException.java new file mode 100644 index 000000000..683df0433 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/ChicoryException.java @@ -0,0 +1,15 @@ +package com.dylibso.chicory.wasm; + +public class ChicoryException extends RuntimeException { + public ChicoryException(String msg) { + super(msg); + } + + public ChicoryException(Throwable cause) { + super(cause); + } + + public ChicoryException(String msg, Throwable cause) { + super(msg, cause); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/ControlTree.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/ControlTree.java new file mode 100644 index 000000000..e19941cc6 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/ControlTree.java @@ -0,0 +1,123 @@ +package com.dylibso.chicory.wasm; + +import com.dylibso.chicory.wasm.types.AnnotatedInstruction; +import com.dylibso.chicory.wasm.types.OpCode; +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; + +/** + * The purpose of this class is to provide a control structure to, in-line, label branches in a list of instructions. + *

+ * Wasm has a structured form of control flow. There is no `jmp` to an address. + * So instead, each branching point can only "jump" to a few points internal to the function + * we are executing in. This algorithm mimics the control flow rules and annotates each + * branching instruction with the labels (here the jumping point is the index of the instruction in the body) + * that it can jump to. Branching instructions can only jump to the beginning of a block if this target is a loop, + * or the end of a block for every other target block. + *

+ * It's up to the Machine to decide, based on what is on the stack, which label to choose. + *

+ * Here is an example on how to label some code. The left side contains indexes. Comments show where the labels go. + * 

+ * 0     (local i32)
+ * 1     (block
+ * 2       (block
+ * 3          (block
+ *                 ;; x == 0
+ * 4               local.get 0
+ * 5               i32.eqz
+ * 6               br_if 0 ;; true=14 false=7
+ *
+ *                 ;; x == 1
+ * 7               local.get 0
+ * 8               i32.const 1
+ * 9               i32.eq
+ * 10              br_if 1 ;; true=17 false=11
+ *
+ *                 ;; the `else` case
+ * 11              i32.const 7
+ * 12              local.set 1
+ * 13              br 2    ;; true=19
+ *            )
+ * 14         i32.const 42
+ * 15         local.set 1
+ * 16         br 1         ;; true=19
+ *            )
+ * 17     i32.const 99
+ * 18     local.set 1
+ *        )
+ * 19   local.get 1)
+ *
+ */ +final class ControlTree { + private final AnnotatedInstruction.Builder instruction; + private final int initialInstructionNumber; + private final ControlTree parent; + private final List nested; + private final List> callbacks; + + ControlTree() { + this.instruction = null; + this.initialInstructionNumber = 0; + this.parent = null; + this.nested = new ArrayList<>(); + this.callbacks = new ArrayList<>(); + } + + private ControlTree( + int initialInstructionNumber, + AnnotatedInstruction.Builder instruction, + ControlTree parent) { + this.instruction = instruction; + this.initialInstructionNumber = initialInstructionNumber; + this.parent = parent; + this.nested = new ArrayList<>(); + this.callbacks = new ArrayList<>(); + } + + ControlTree spawn(int initialInstructionNumber, AnnotatedInstruction.Builder instruction) { + var node = new ControlTree(initialInstructionNumber, instruction, this); + this.addNested(node); + return node; + } + + AnnotatedInstruction.Builder instruction() { + return instruction; + } + + int instructionNumber() { + return initialInstructionNumber; + } + + void addNested(ControlTree nested) { + this.nested.add(nested); + } + + ControlTree parent() { + return parent; + } + + void addCallback(Consumer callback) { + this.callbacks.add(callback); + } + + void setFinalInstructionNumber(int finalInstructionNumber, AnnotatedInstruction.Builder end) { + // to be set when END is reached + if (end.scope().isPresent() && end.scope().get().opcode() == OpCode.LOOP) { + var lastLoopInstruction = 0; + if (this.parent != null) { + for (var ct : this.parent.nested) { + if (ct.instruction().opcode() == OpCode.LOOP) { + lastLoopInstruction = ct.instructionNumber(); + } + } + } + finalInstructionNumber = lastLoopInstruction + 1; + } + + for (var callback : this.callbacks) { + callback.accept(finalInstructionNumber); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/Encoding.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/Encoding.java new file mode 100644 index 000000000..a5eb004aa --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/Encoding.java @@ -0,0 +1,233 @@ +package com.dylibso.chicory.wasm; + +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; + +public final class Encoding { + + // https://webassembly.github.io/spec/core/binary/values.html#integers + public static final int MAX_VARINT_LEN_32 = 5; // ceil(32/7) + public static final int MAX_VARINT_LEN_64 = 10; // ceil(64/7) + + private Encoding() {} + + static int readInt(ByteBuffer buffer) { + if (buffer.remaining() < 4) { + throw new MalformedException("length out of bounds"); + } + return buffer.getInt(); + } + + static byte readByte(ByteBuffer buffer) { + if (!buffer.hasRemaining()) { + throw new MalformedException("length out of bounds"); + } + return buffer.get(); + } + + static void readBytes(ByteBuffer buffer, byte[] dest) { + if (buffer.remaining() < dest.length) { + throw new MalformedException("length out of bounds"); + } + buffer.get(dest); + } + + // https://webassembly.github.io/spec/core/syntax/values.html#integers + public static final long MIN_SIGNED_INT = Integer.MIN_VALUE; // -2^(32-1) + public static final long MAX_SIGNED_INT = Integer.MAX_VALUE; // 2^(32-1)-1 + public static final long MAX_UNSIGNED_INT = 0xFFFFFFFFL; // 2^(32)-1 + + /** + * Read an unsigned I32 from the buffer. We can't fit an unsigned 32bit int + * into a java int, so we must use a long. + * See 2.2.2. Integers of the WebAssembly Core Specification. + * + * @param buffer the byte buffer + * @return the resulting long + */ + public static long readVarUInt32(ByteBuffer buffer) { + var value = readUnsignedLeb128(buffer, MAX_VARINT_LEN_32); + if (value < 0 || value > MAX_UNSIGNED_INT) { + throw new MalformedException("integer too large"); + } + return value; + } + + /** + * Read a signed I32 from the buffer. We can't fit an unsigned 32bit int into a java int, so we must use a long to use the same type as unsigned. + * See 2.2.2. Integers of the WebAssembly Core Specification. + * + * @param buffer the byte buffer + * @return the resulting long + */ + public static long readVarSInt32(ByteBuffer buffer) { + var value = readSigned32Leb128(buffer); + if (value < MIN_SIGNED_INT || value > MAX_SIGNED_INT) { + throw new MalformedException("integer too large"); + } + return value; + } + + /** + * Read a signed I64 from the buffer which fits neatly into a long. + * See 2.2.2. Integers of the WebAssembly Core Specification. + * + * @param buffer the byte buffer + * @return the resulting long + */ + public static long readVarSInt64(ByteBuffer buffer) { + return readSigned64Leb128(buffer); + } + + /** + * Read a F64 from the buffer which fits neatly into a long. + * See 2.2.3. Floating-Point of the WebAssembly Core Specification. + * + * @param buffer the byte buffer + * @return the resulting long + */ + public static long readFloat64(ByteBuffer buffer) { + return buffer.getLong(); + } + + /** + * Read a F32 from the buffer which fits neatly into a long. + * See 2.2.3. Floating-Point of the WebAssembly Core Specification. + * + * @param buffer the byte buffer + * @return the resulting long + */ + public static long readFloat32(ByteBuffer buffer) { + return readInt(buffer); + } + + /** + * Read a symbol name from the buffer as UTF-8 String. + * See 2.2.4. Names of the WebAssembly Core Specification. + * + * @param buffer the byte buffer + * @return the resulting long + */ + public static String readName(ByteBuffer buffer) { + return readName(buffer, true); + } + + /** + * Read a symbol name from the buffer as UTF-8 String. + * See 2.2.4. Names of the WebAssembly Core Specification. + * + * @param buffer the byte buffer + * @param checkMalformed verify if it's a valid identifier + * @return the resulting long + */ + public static String readName(ByteBuffer buffer, boolean checkMalformed) { + var length = (int) readVarUInt32(buffer); + byte[] bytes = new byte[length]; + readBytes(buffer, bytes); + var name = new String(bytes, StandardCharsets.UTF_8); + if (checkMalformed && !isValidIdentifier(name)) { + throw new MalformedException("malformed UTF-8 encoding"); + } + return name; + } + + private static boolean isValidIdentifier(String string) { + return string.chars().allMatch(ch -> ch < 0x80 || Character.isUnicodeIdentifierPart(ch)); + } + + /** + * Reads an unsigned integer from {@code byteBuffer}. + */ + public static long readUnsignedLeb128(ByteBuffer byteBuffer, int maxVarInt) { + long result = 0; + int shift = 0; + int i = 0; + while (true) { + i++; + if (byteBuffer.remaining() == 0) { + throw new MalformedException( + "integer too large, integer representation too long, length out of bounds"); + } + byte b = byteBuffer.get(); + result |= (long) (b & 0x7F) << shift; + + if ((b & 0x80) == 0) { + break; + } + + if (i >= maxVarInt || byteBuffer.remaining() == 0) { + throw new MalformedException("integer representation too long"); + } + + shift += 7; + } + + return result; + } + + /** + * Reads an unsigned integer from {@code byteBuffer}. + */ + public static long readSigned32Leb128(ByteBuffer byteBuffer) { + long result = 0; + int shift = 0; + int i = 0; + byte currentByte; + + do { + i++; + if (byteBuffer.remaining() == 0) { + throw new MalformedException( + "integer representation too long, length out of bounds"); + } + + currentByte = byteBuffer.get(); + if ((currentByte & 0x80) != 0 && i >= MAX_VARINT_LEN_32) { + throw new MalformedException("integer representation too long"); + } + result |= (long) (currentByte & 0x7F) << shift; + shift += 7; + } while ((currentByte & 0x80) != 0); + + // If the final byte read has its sign bit set (0x40), then sign-extend the result + if ((currentByte & 0x40) != 0) { + result |= -(1L << shift); + } + + return result; + } + + public static long readSigned64Leb128(ByteBuffer byteBuffer) { + long result = 0; + int shift = 0; + int i = 0; + byte currentByte; + int size = 64; // 64 bits for i64 + + do { + i++; + if (byteBuffer.remaining() == 0) { + throw new MalformedException( + "integer representation too long, length out of bounds"); + } + + currentByte = byteBuffer.get(); + if ((currentByte & 0x80) != 0 && i >= MAX_VARINT_LEN_64) { + throw new MalformedException("integer representation too long"); + } + result |= (long) (currentByte & 0x7F) << shift; + shift += 7; + } while ((currentByte & 0x80) != 0); + + // If the final byte read has its sign bit set (0x40), then sign-extend the result + if (shift < size && (currentByte & 0x40) != 0) { + result |= -1L << shift; + } + + if (i >= MAX_VARINT_LEN_64 && currentByte != 0 && currentByte < 0x7F) { + throw new MalformedException("integer too large"); + } + + return result; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/InvalidException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/InvalidException.java new file mode 100644 index 000000000..0b9533f9b --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/InvalidException.java @@ -0,0 +1,15 @@ +package com.dylibso.chicory.wasm; + +public class InvalidException extends ChicoryException { + public InvalidException(String msg) { + super(msg); + } + + public InvalidException(Throwable cause) { + super(cause); + } + + public InvalidException(String msg, Throwable cause) { + super(msg, cause); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/MalformedException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/MalformedException.java new file mode 100644 index 000000000..040197633 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/MalformedException.java @@ -0,0 +1,15 @@ +package com.dylibso.chicory.wasm; + +public class MalformedException extends ChicoryException { + public MalformedException(String msg) { + super(msg); + } + + public MalformedException(Throwable cause) { + super(cause); + } + + public MalformedException(String msg, Throwable cause) { + super(msg, cause); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/Parser.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/Parser.java new file mode 100644 index 000000000..a1767c67d --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/Parser.java @@ -0,0 +1,1371 @@ +package com.dylibso.chicory.wasm; + +import static com.dylibso.chicory.wasm.Encoding.readByte; +import static com.dylibso.chicory.wasm.Encoding.readBytes; +import static com.dylibso.chicory.wasm.Encoding.readFloat32; +import static com.dylibso.chicory.wasm.Encoding.readFloat64; +import static com.dylibso.chicory.wasm.Encoding.readName; +import static com.dylibso.chicory.wasm.Encoding.readVarSInt32; +import static com.dylibso.chicory.wasm.Encoding.readVarSInt64; +import static com.dylibso.chicory.wasm.Encoding.readVarUInt32; +import static com.dylibso.chicory.wasm.WasmLimits.MAX_FUNCTION_LOCALS; +import static com.dylibso.chicory.wasm.types.Instruction.EMPTY_OPERANDS; +import static java.util.Objects.requireNonNull; + +import com.dylibso.chicory.wasm.io.InputStreams; +import com.dylibso.chicory.wasm.types.ActiveDataSegment; +import com.dylibso.chicory.wasm.types.ActiveElement; +import com.dylibso.chicory.wasm.types.AnnotatedInstruction; +import com.dylibso.chicory.wasm.types.CatchOpCode; +import com.dylibso.chicory.wasm.types.CodeSection; +import com.dylibso.chicory.wasm.types.CustomSection; +import com.dylibso.chicory.wasm.types.DataCountSection; +import com.dylibso.chicory.wasm.types.DataSection; +import com.dylibso.chicory.wasm.types.DeclarativeElement; +import com.dylibso.chicory.wasm.types.Element; +import com.dylibso.chicory.wasm.types.ElementSection; +import com.dylibso.chicory.wasm.types.Export; +import com.dylibso.chicory.wasm.types.ExportSection; +import com.dylibso.chicory.wasm.types.ExternalType; +import com.dylibso.chicory.wasm.types.FunctionBody; +import com.dylibso.chicory.wasm.types.FunctionImport; +import com.dylibso.chicory.wasm.types.FunctionSection; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.Global; +import com.dylibso.chicory.wasm.types.GlobalImport; +import com.dylibso.chicory.wasm.types.GlobalSection; +import com.dylibso.chicory.wasm.types.ImportSection; +import com.dylibso.chicory.wasm.types.Instruction; +import com.dylibso.chicory.wasm.types.Memory; +import com.dylibso.chicory.wasm.types.MemoryImport; +import com.dylibso.chicory.wasm.types.MemoryLimits; +import com.dylibso.chicory.wasm.types.MemorySection; +import com.dylibso.chicory.wasm.types.MutabilityType; +import com.dylibso.chicory.wasm.types.NameCustomSection; +import com.dylibso.chicory.wasm.types.OpCode; +import com.dylibso.chicory.wasm.types.PassiveDataSegment; +import com.dylibso.chicory.wasm.types.PassiveElement; +import com.dylibso.chicory.wasm.types.RawSection; +import com.dylibso.chicory.wasm.types.Section; +import com.dylibso.chicory.wasm.types.SectionId; +import com.dylibso.chicory.wasm.types.StartSection; +import com.dylibso.chicory.wasm.types.Table; +import com.dylibso.chicory.wasm.types.TableImport; +import com.dylibso.chicory.wasm.types.TableLimits; +import com.dylibso.chicory.wasm.types.TableSection; +import com.dylibso.chicory.wasm.types.TagImport; +import com.dylibso.chicory.wasm.types.TagSection; +import com.dylibso.chicory.wasm.types.TagType; +import com.dylibso.chicory.wasm.types.TypeSection; +import com.dylibso.chicory.wasm.types.UnknownCustomSection; +import com.dylibso.chicory.wasm.types.ValType; +import com.dylibso.chicory.wasm.types.Value; +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.file.Files; +import java.nio.file.Path; +import java.security.DigestInputStream; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.BitSet; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * Parser for Web Assembly binaries. + */ +@SuppressWarnings("UnnecessaryCodeBlock") +public final class Parser { + private static final String DIGEST_ALGORITHM = + System.getProperty("com.dylibso.chicory.wasm.Parser.DIGEST_ALGORITHM", "SHA-256"); + + static final byte[] MAGIC_BYTES = {0x00, 0x61, 0x73, 0x6D}; // Magic prefix \0asm + static final byte[] VERSION_BYTES = {0x01, 0x00, 0x00, 0x00}; // Version 1 + + private final Map> customParsers; + private final BitSet includeSections; + + private TypeSection typeSection; + + private static final Map> DEFAULT_CUSTOM_PARSERS = + Map.of("name", NameCustomSection::parse); + + private Parser() { + this(null, DEFAULT_CUSTOM_PARSERS); + } + + private Parser( + BitSet includeSections, Map> customParsers) { + this.includeSections = includeSections; + this.customParsers = Map.copyOf(customParsers); + this.typeSection = TypeSection.builder().build(); + } + + private static ByteBuffer readByteBuffer(InputStream is) { + try { + var buffer = ByteBuffer.wrap(InputStreams.readAllBytes(is)); + buffer.order(ByteOrder.LITTLE_ENDIAN); + return buffer; + } catch (IOException e) { + throw new IllegalArgumentException("Failed to read wasm bytes.", e); + } + } + + private static void onSection(WasmModule.Builder module, Section s) { + switch (s.sectionId()) { + case SectionId.CUSTOM: + var customSection = (CustomSection) s; + module.addCustomSection(customSection.name(), customSection); + break; + case SectionId.TYPE: + module.setTypeSection((TypeSection) s); + break; + case SectionId.IMPORT: + module.setImportSection((ImportSection) s); + break; + case SectionId.FUNCTION: + module.setFunctionSection((FunctionSection) s); + break; + case SectionId.TABLE: + module.setTableSection((TableSection) s); + break; + case SectionId.MEMORY: + module.setMemorySection((MemorySection) s); + break; + case SectionId.GLOBAL: + module.setGlobalSection((GlobalSection) s); + break; + case SectionId.EXPORT: + module.setExportSection((ExportSection) s); + break; + case SectionId.START: + module.setStartSection((StartSection) s); + break; + case SectionId.ELEMENT: + module.setElementSection((ElementSection) s); + break; + case SectionId.CODE: + module.setCodeSection((CodeSection) s); + break; + case SectionId.DATA: + module.setDataSection((DataSection) s); + break; + case SectionId.DATA_COUNT: + module.setDataCountSection((DataCountSection) s); + break; + case SectionId.TAG: + module.setTagSection((TagSection) s); + break; + default: + module.addIgnoredSection(s.sectionId()); + break; + } + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private Map> customParsers; + private BitSet includeSections; + + private Builder() {} + + /** + * @param sectionId : the sectionId to be included while parsing, e.g. SectionId.MEMORY + */ + public Builder includeSectionId(int sectionId) { + if (includeSections == null) { + includeSections = new BitSet(); + } + includeSections.set(sectionId); + return this; + } + + public Builder withCustomParsers( + Map> customParsers) { + this.customParsers = customParsers; + return this; + } + + public Parser build() { + if (customParsers == null) { + customParsers = DEFAULT_CUSTOM_PARSERS; + } + return new Parser(includeSections, customParsers); + } + } + + public static WasmModule parse(InputStream input) { + return new Parser().parse(() -> input); + } + + public static WasmModule parse(byte[] buffer) { + return new Parser().parse(() -> new ByteArrayInputStream(buffer)); + } + + public static WasmModule parse(File file) { + return parse(file.toPath()); + } + + public static WasmModule parse(Path path) { + return new Parser() + .parse( + () -> { + try { + return Files.newInputStream(path); + } catch (IOException e) { + throw new IllegalArgumentException( + "Error opening file: " + path, e); + } + }); + } + + public WasmModule parse(Supplier inputStreamSupplier) { + WasmModule.Builder moduleBuilder = WasmModule.builder(); + MessageDigest messageDigest = null; + try (InputStream is = inputStreamSupplier.get()) { + InputStream maybeDigestedInputStream = is; + if (!"none".equals(DIGEST_ALGORITHM)) { + // wrap the input stream so we can calculate the digest hash of the wasm module + messageDigest = MessageDigest.getInstance(DIGEST_ALGORITHM); + maybeDigestedInputStream = new DigestInputStream(is, messageDigest); + } + parse(maybeDigestedInputStream, (s) -> onSection(moduleBuilder, s)); + } catch (IOException | NoSuchAlgorithmException e) { + throw new ChicoryException(e); + } catch (MalformedException e) { + throw new MalformedException( + "section size mismatch, unexpected end of section or function, " + + e.getMessage(), + e); + } + if (messageDigest != null) { + String algo = DIGEST_ALGORITHM.toLowerCase(Locale.getDefault()).replace(":", ""); + moduleBuilder.withDigest( + algo + ":" + Base64.getEncoder().encodeToString(messageDigest.digest())); + } + return moduleBuilder.build(); + } + + public void parse(InputStream in, ParserListener listener) { + parse(in, listener, true); + } + + private void parse(InputStream in, ParserListener listener, boolean decode) { + + requireNonNull(listener, "listener"); + var validator = new SectionsValidator(); + + var buffer = readByteBuffer(in); + + byte[] magic = new byte[4]; + readBytes(buffer, magic); + if (!Arrays.equals(magic, MAGIC_BYTES)) { + throw new MalformedException( + "magic header not detected, found: " + + Arrays.toString(magic) + + " expected: " + + Arrays.toString(MAGIC_BYTES)); + } + + byte[] version = new byte[4]; + readBytes(buffer, version); + if (!Arrays.equals(version, VERSION_BYTES)) { + throw new MalformedException( + "unknown binary version, found: " + + Arrays.toString(version) + + " expected: " + + Arrays.toString(VERSION_BYTES)); + } + + // check if the custom section has malformed names only the first time that is parsed + var firstTime = true; + + while (buffer.hasRemaining()) { + var sectionId = readByte(buffer); + var sectionSize = readVarUInt32(buffer); + + validator.validateSectionType(sectionId); + + ByteBuffer sectionByteBuffer = buffer.asReadOnlyBuffer(); + sectionByteBuffer.order(buffer.order()); + + // move buffer to next section + var sectionLimit = sectionByteBuffer.position() + (int) sectionSize; + if (buffer.capacity() < sectionLimit) { + throw new MalformedException("length out of bounds for section" + sectionId); + } + buffer.position(sectionLimit); + + if (shouldParseSection(sectionId)) { + sectionByteBuffer.limit(sectionLimit); + + if (!decode) { + listener.onSection(parseRawSection(sectionByteBuffer, sectionId, sectionSize)); + continue; + } + + // Process different section types based on the sectionId + switch (sectionId) { + case SectionId.CUSTOM: + { + var customSection = + parseCustomSection(sectionByteBuffer, sectionSize, firstTime); + firstTime = false; + listener.onSection(customSection); + break; + } + case SectionId.TYPE: + { + var typeSection = parseTypeSection(sectionByteBuffer); + this.typeSection = typeSection; + listener.onSection(typeSection); + break; + } + case SectionId.IMPORT: + { + var importSection = parseImportSection(sectionByteBuffer, typeSection); + listener.onSection(importSection); + break; + } + case SectionId.FUNCTION: + { + var funcSection = parseFunctionSection(sectionByteBuffer); + listener.onSection(funcSection); + break; + } + case SectionId.TABLE: + { + var tableSection = parseTableSection(sectionByteBuffer, typeSection); + listener.onSection(tableSection); + break; + } + case SectionId.MEMORY: + { + var memorySection = parseMemorySection(sectionByteBuffer); + listener.onSection(memorySection); + break; + } + case SectionId.TAG: + { + var tagSection = parseTagSection(sectionByteBuffer); + listener.onSection(tagSection); + break; + } + case SectionId.GLOBAL: + { + var globalSection = parseGlobalSection(sectionByteBuffer, typeSection); + listener.onSection(globalSection); + break; + } + case SectionId.EXPORT: + { + var exportSection = parseExportSection(sectionByteBuffer); + listener.onSection(exportSection); + break; + } + case SectionId.START: + { + var startSection = parseStartSection(sectionByteBuffer); + listener.onSection(startSection); + break; + } + case SectionId.ELEMENT: + { + var elementSection = + parseElementSection( + sectionByteBuffer, sectionSize, typeSection); + listener.onSection(elementSection); + break; + } + case SectionId.CODE: + { + var codeSection = parseCodeSection(sectionByteBuffer, typeSection); + listener.onSection(codeSection); + break; + } + case SectionId.DATA: + { + var dataSection = parseDataSection(sectionByteBuffer); + listener.onSection(dataSection); + break; + } + case SectionId.DATA_COUNT: + { + var dataCountSection = parseDataCountSection(sectionByteBuffer); + listener.onSection(dataCountSection); + break; + } + default: + { + throw new MalformedException( + "section size mismatch, malformed section id " + sectionId); + } + } + + if (sectionByteBuffer.hasRemaining()) { + throw new MalformedException("section size mismatch"); + } + } + } + } + + public static void parseWithoutDecoding(byte[] bytes, ParserListener listener) { + new Parser().parseWithoutDecoding(new ByteArrayInputStream(bytes), listener); + } + + public void parseWithoutDecoding(InputStream in, ParserListener listener) { + parse(in, listener, false); + } + + // https://webassembly.github.io/spec/core/binary/modules.html#binary-module + private static class SectionsValidator { + private List sectionsOrder = new ArrayList<>(); + private int maxSection = -1; + + SectionsValidator() { + sectionsOrder.add(SectionId.TYPE); + sectionsOrder.add(SectionId.IMPORT); + sectionsOrder.add(SectionId.FUNCTION); + sectionsOrder.add(SectionId.TABLE); + sectionsOrder.add(SectionId.MEMORY); + sectionsOrder.add(SectionId.GLOBAL); + sectionsOrder.add(SectionId.EXPORT); + sectionsOrder.add(SectionId.START); + sectionsOrder.add(SectionId.ELEMENT); + sectionsOrder.add(SectionId.DATA_COUNT); + sectionsOrder.add(SectionId.CODE); + sectionsOrder.add(SectionId.DATA); + } + + void validateSectionType(byte sectionId) { + if (sectionsOrder.contains((int) sectionId)) { + if (maxSection < 0 || sectionsOrder.indexOf((int) sectionId) > maxSection) { + maxSection = sectionsOrder.indexOf((int) sectionId); + } else { + throw new MalformedException("unexpected content after last section"); + } + } + } + } + + private boolean shouldParseSection(int sectionId) { + return (this.includeSections == null) || (this.includeSections.get(sectionId)); + } + + private CustomSection parseCustomSection( + ByteBuffer buffer, long sectionSize, boolean checkMalformed) { + var sectionPos = buffer.position(); + var name = readName(buffer, checkMalformed); + var size = (sectionSize - (buffer.position() - sectionPos)); + if (size < 0) { + throw new MalformedException("unexpected end"); + } + var bytes = new byte[(int) size]; + readBytes(buffer, bytes); + var parser = customParsers.get(name); + return parser == null + ? UnknownCustomSection.builder().withName(name).withBytes(bytes).build() + : parser.apply(bytes); + } + + private static RawSection parseRawSection(ByteBuffer buffer, byte sectionId, long sectionSize) { + var bytes = new byte[Math.toIntExact(sectionSize)]; + readBytes(buffer, bytes); + return new RawSection(sectionId, bytes); + } + + private static TypeSection parseTypeSection(ByteBuffer buffer) { + + var typeCount = readVarUInt32(buffer); + TypeSection.Builder typeSection = TypeSection.builder(); + + // Parse individual types in the type section + for (int i = 0; i < typeCount; i++) { + var form = readVarUInt32(buffer); + if (form > Byte.MAX_VALUE) { + throw new MalformedException("integer representation too long"); + } + + if (form != 0x60) { + throw new MalformedException( + "We don't support non func types. Form " + + String.format("0x%02X", form) + + " was given but we expected 0x60"); + } + + // Parse function types (form = 0x60) + var paramCount = (int) readVarUInt32(buffer); + var paramsBuilder = new ValType.Builder[paramCount]; + + // Parse parameter types + for (int j = 0; j < paramCount; j++) { + paramsBuilder[j] = readValueTypeBuilder(buffer); + } + + var returnCount = (int) readVarUInt32(buffer); + var returnsBuilder = new ValType.Builder[returnCount]; + + // Parse return types + for (int j = 0; j < returnCount; j++) { + returnsBuilder[j] = readValueTypeBuilder(buffer); + } + + // a type can only refer to types with idx less than it + var maxTypeIdx = i - 1; + Stream.concat(Arrays.stream(paramsBuilder), Arrays.stream(returnsBuilder)) + .forEach( + v -> { + if (v.isReference()) { + var typeIdx = v.typeIdx(); + if (typeIdx > maxTypeIdx) { + throw new InvalidException( + "unknown type: recursive type, type mismatch"); + } + } + }); + + Function build = + (ValType.Builder builder) -> builder.build(typeSection.getTypes()::get); + + var params = Arrays.stream(paramsBuilder).map(build).toArray(ValType[]::new); + var returns = Arrays.stream(returnsBuilder).map(build).toArray(ValType[]::new); + + typeSection.addFunctionType(FunctionType.of(params, returns)); + } + + return typeSection.build(); + } + + private static ImportSection parseImportSection(ByteBuffer buffer, TypeSection typeSection) { + + var importCount = readVarUInt32(buffer); + ImportSection.Builder importSection = ImportSection.builder(); + + // Parse individual imports in the import section + for (int i = 0; i < importCount; i++) { + String moduleName = readName(buffer); + String importName = readName(buffer); + ExternalType descType; + try { + descType = ExternalType.byId((int) readVarUInt32(buffer)); + } catch (RuntimeException e) { + throw new MalformedException("malformed import kind", e); + } + switch (descType) { + case FUNCTION: + { + if (moduleName.isEmpty() && importName.isEmpty()) { + throw new MalformedException("malformed import kind"); + } + importSection.addImport( + new FunctionImport( + moduleName, importName, (int) readVarUInt32(buffer))); + break; + } + case TABLE: + { + var rawTableType = readValueType(buffer, typeSection); + + var limitType = readByte(buffer); + var min = (int) readVarUInt32(buffer); + TableLimits limits = null; + switch (limitType) { + case 0x00: + limits = new TableLimits(min); + break; + case 0x01: + case 0x03: + limits = + new TableLimits( + min, readVarUInt32(buffer), limitType == 0x03); + break; + default: + throw new MalformedException( + "integer too large, invalid table limit: " + limitType); + } + + importSection.addImport( + new TableImport(moduleName, importName, rawTableType, limits)); + break; + } + case MEMORY: + { + var limits = parseMemoryLimits(buffer); + importSection.addImport(new MemoryImport(moduleName, importName, limits)); + break; + } + case GLOBAL: + var globalValType = readValueType(buffer, typeSection); + var globalMut = MutabilityType.forId(readByte(buffer)); + importSection.addImport( + new GlobalImport(moduleName, importName, globalMut, globalValType)); + break; + case TAG: + try { + var attribute = readByte(buffer); + var tagTypeIdx = (int) readVarUInt32(buffer); + importSection.addImport( + new TagImport(moduleName, importName, attribute, tagTypeIdx)); + } catch (MalformedException e) { + throw new MalformedException("malformed import kind", e); + } + break; + default: + throw new MalformedException("malformed import kind"); + } + } + + return importSection.build(); + } + + private static FunctionSection parseFunctionSection(ByteBuffer buffer) { + + var functionCount = readVarUInt32(buffer); + FunctionSection.Builder functionSection = FunctionSection.builder(); + + // Parse individual functions in the function section + for (int i = 0; i < functionCount; i++) { + var typeIndex = readVarUInt32(buffer); + functionSection.addFunctionType((int) typeIndex); + } + + return functionSection.build(); + } + + private static TableLimits readTableLimits(ByteBuffer buffer) { + var limitType = readByte(buffer); + if (!(limitType == 0x00 || limitType == 0x01)) { + throw new MalformedException("integer representation too long, integer too large"); + } + var min = readVarUInt32(buffer); + var limits = + limitType > 0 ? new TableLimits(min, readVarUInt32(buffer)) : new TableLimits(min); + return limits; + } + + private static TableSection parseTableSection(ByteBuffer buffer, TypeSection typeSection) { + + var tableCount = readVarUInt32(buffer); + TableSection.Builder tableSection = TableSection.builder(); + + // Parse individual tables in the tables section + for (int i = 0; i < tableCount; i++) { + var firstByte = (int) readVarUInt32(buffer); + if (firstByte == 0x40) { + var secondByte = readVarUInt32(buffer); + assert secondByte == 0x00; + var tableType = readValueType(buffer, typeSection); + var limits = readTableLimits(buffer); + var init = parseExpression(buffer); + tableSection.addTable(new Table(tableType, limits, List.of(init))); + } else { + var tableType = readValueTypeFromOpCode(buffer, firstByte, typeSection); + var limits = readTableLimits(buffer); + tableSection.addTable(new Table(tableType, limits)); + } + } + + return tableSection.build(); + } + + private static MemorySection parseMemorySection(ByteBuffer buffer) { + + var memoryCount = readVarUInt32(buffer); + MemorySection.Builder memorySection = MemorySection.builder(); + + // Parse individual memories in the memory section + for (int i = 0; i < memoryCount; i++) { + var limits = parseMemoryLimits(buffer); + memorySection.addMemory(new Memory(limits)); + } + + return memorySection.build(); + } + + private static MemoryLimits parseMemoryLimits(ByteBuffer buffer) { + var limitType = readByte(buffer); + var initial = (int) readVarUInt32(buffer); + switch (limitType) { + case 0x00: + return new MemoryLimits(initial); + case 0x01: + case 0x03: + int maximum = (int) readVarUInt32(buffer); + return new MemoryLimits(initial, maximum, limitType == 0x03); + case 0x02: + throw new InvalidException("shared memory must have maximum"); + default: + if (limitType > 0) { + throw new MalformedException( + "integer too large, invalid memory limit: " + limitType); + } else { + throw new MalformedException("integer representation too long: " + limitType); + } + } + } + + private static GlobalSection parseGlobalSection(ByteBuffer buffer, TypeSection typeSection) { + + var globalCount = readVarUInt32(buffer); + GlobalSection.Builder globalSection = GlobalSection.builder(); + + // Parse individual globals + for (int i = 0; i < globalCount; i++) { + var valueType = readValueType(buffer, typeSection); + var mutabilityType = MutabilityType.forId(readByte(buffer)); + var init = parseExpression(buffer); + globalSection.addGlobal(new Global(valueType, mutabilityType, List.of(init))); + } + + return globalSection.build(); + } + + private static ExportSection parseExportSection(ByteBuffer buffer) { + + var exportCount = readVarUInt32(buffer); + ExportSection.Builder exportSection = ExportSection.builder(); + + // Parse individual functions in the function section + for (int i = 0; i < exportCount; i++) { + var name = readName(buffer, false); + var exportType = ExternalType.byId((int) readVarUInt32(buffer)); + var index = (int) readVarUInt32(buffer); + exportSection.addExport(new Export(name, index, exportType)); + } + + return exportSection.build(); + } + + private static StartSection parseStartSection(ByteBuffer buffer) { + return StartSection.builder().setStartIndex(readVarUInt32(buffer)).build(); + } + + private static ElementSection parseElementSection( + ByteBuffer buffer, long sectionSize, TypeSection typeSection) { + var initialPosition = buffer.position(); + + var elementCount = readVarUInt32(buffer); + ElementSection.Builder elementSection = ElementSection.builder(); + + for (var i = 0; i < elementCount; i++) { + elementSection.addElement(parseSingleElement(buffer, typeSection)); + } + if (buffer.position() != initialPosition + sectionSize) { + throw new MalformedException("section size mismatch"); + } + + return elementSection.build(); + } + + private static Element parseSingleElement(ByteBuffer buffer, TypeSection typeSection) { + // Elements are actually fairly complex to parse. + // See https://webassembly.github.io/spec/core/binary/modules.html#element-section + + int flags = (int) readVarUInt32(buffer); + + // Active elements have bit 0 clear + boolean active = (flags & 0b001) == 0; + // Declarative elements are non-active elements with bit 1 set + boolean declarative = !active && (flags & 0b010) != 0; + // Otherwise, it's passive + boolean passive = !active && !declarative; + + // Now, characteristics for parsing + // Does the (active) segment have a table index, or is it always 0? + boolean hasTableIdx = active && (flags & 0b010) != 0; + // Is the type always funcref, or do we have to read the type? + boolean alwaysFuncRef = active && !hasTableIdx; + // Are initializers expressions or function indices? + boolean exprInit = (flags & 0b100) != 0; + // Is the type encoded as an elemkind? + boolean hasElemKind = !exprInit && !alwaysFuncRef; + // Is the type encoded as a reftype? + boolean hasRefType = exprInit && !alwaysFuncRef; + + // the table index is assumed to be zero + int tableIdx = 0; + List offset = List.of(); + + if (active) { + if (hasTableIdx) { + tableIdx = Math.toIntExact(readVarUInt32(buffer)); + } + offset = List.of(parseExpression(buffer)); + } + // common path + ValType type; + if (alwaysFuncRef) { + if (exprInit) { + type = ValType.FuncRef; + } else { + type = + ValType.builder() + .withOpcode(ValType.ID.Ref) + .withTypeIdx(ValType.TypeIdxCode.FUNC.code()) + .build(); + } + } else if (hasElemKind) { + int ek = (int) readVarUInt32(buffer); + if (ek == 0x00) { + type = + ValType.builder() + .withOpcode(ValType.ID.Ref) + .withTypeIdx(ValType.TypeIdxCode.FUNC.code()) + .build(); + } else { + throw new ChicoryException("Invalid element kind"); + } + } else { + assert hasRefType; + type = readValueType(buffer, typeSection); + if (!type.isReference()) { + throw new MalformedException( + "malformed reference type: element section has non-reference type"); + } + } + int initCnt = Math.toIntExact(readVarUInt32(buffer)); + List> inits = new ArrayList<>(initCnt); + if (exprInit) { + // read the expressions directly from the stream + for (int i = 0; i < initCnt; i++) { + inits.add(List.of(parseExpression(buffer))); + } + } else { + // read function references, and compose them as instruction lists + for (int i = 0; i < initCnt; i++) { + inits.add( + List.of( + new Instruction( + -1, OpCode.REF_FUNC, new long[] {readVarUInt32(buffer)}), + new Instruction(-1, OpCode.END, EMPTY_OPERANDS))); + } + } + if (declarative) { + return new DeclarativeElement(type, inits); + } + if (passive) { + return new PassiveElement(type, inits); + } + assert active; + return new ActiveElement(type, inits, tableIdx, offset); + } + + private static List parseCodeSectionLocalTypes( + ByteBuffer buffer, TypeSection typeSection) { + var distinctTypesCount = readVarUInt32(buffer); + var locals = new ArrayList(); + + for (int i = 0; i < distinctTypesCount; i++) { + var numberOfLocals = readVarUInt32(buffer); + if (numberOfLocals > MAX_FUNCTION_LOCALS) { + throw new MalformedException("too many locals"); + } + var type = readValueType(buffer, typeSection); + for (int j = 0; j < numberOfLocals; j++) { + locals.add(type); + } + } + + return locals; + } + + private static CodeSection parseCodeSection(ByteBuffer buffer, TypeSection typeSection) { + var funcBodyCount = readVarUInt32(buffer); + + var root = new ControlTree(); + var codeSection = CodeSection.builder(); + + // Parse individual function bodies in the code section + for (int i = 0; i < funcBodyCount; i++) { + var blockScope = new ArrayDeque(); + var depth = 0; + var funcEndPoint = readVarUInt32(buffer) + buffer.position(); + var locals = parseCodeSectionLocalTypes(buffer, typeSection); + var instructions = new ArrayList(); + var lastInstruction = false; + ControlTree currentControlFlow = null; + + do { + var baseInstruction = parseInstruction(buffer); + var instruction = AnnotatedInstruction.builder().from(baseInstruction); + lastInstruction = buffer.position() >= funcEndPoint; + if (instructions.isEmpty()) { + currentControlFlow = root.spawn(0, instruction); + } + + // https://webassembly.github.io/spec/core/binary/modules.html#data-count-section + switch (baseInstruction.opcode()) { + case MEMORY_INIT: + case DATA_DROP: + codeSection.setRequiresDataCount(true); + } + + // depth control + switch (baseInstruction.opcode()) { + case BLOCK: + case LOOP: + case IF: + case TRY_TABLE: + { + depth++; + instruction.withDepth(depth); + blockScope.push(baseInstruction); + instruction.withScope(blockScope.peek()); + break; + } + case END: + { + instruction.withDepth(depth); + depth--; + instruction.withScope( + blockScope.isEmpty() ? baseInstruction : blockScope.pop()); + break; + } + default: + { + instruction.withDepth(depth); + break; + } + } + + // control-flow + switch (baseInstruction.opcode()) { + case BLOCK: + case LOOP: + { + currentControlFlow = + currentControlFlow.spawn(instructions.size(), instruction); + break; + } + case IF: + { + currentControlFlow = + currentControlFlow.spawn(instructions.size(), instruction); + + var defaultJmp = instructions.size() + 1; + currentControlFlow.addCallback( + end -> { + // check that there is no "else" branch + instruction.updateLabelFalse(end); + }); + + // defaults + instruction.withLabelTrue(defaultJmp); + instruction.withLabelFalse(defaultJmp); + break; + } + case ELSE: + { + currentControlFlow + .instruction() + .withLabelFalse(instructions.size() + 1); + + currentControlFlow.addCallback(instruction::withLabelTrue); + + break; + } + case BR_IF: + case BR_ON_NULL: + case BR_ON_NON_NULL: + { + instruction.withLabelFalse(instructions.size() + 1); + } + // fallthrough + case BR: + { + var offset = (int) baseInstruction.operand(0); + ControlTree reference = currentControlFlow; + while (offset > 0) { + if (reference == null) { + throw new InvalidException("unknown label"); + } + reference = reference.parent(); + offset--; + } + reference.addCallback(instruction::withLabelTrue); + break; + } + case BR_TABLE: + { + var length = baseInstruction.operandCount(); + var labelTable = new ArrayList(); + for (var idx = 0; idx < length; idx++) { + labelTable.add(null); + var offset = (int) baseInstruction.operand(idx); + ControlTree reference = currentControlFlow; + while (offset > 0) { + if (reference == null) { + throw new InvalidException("unknown label"); + } + reference = reference.parent(); + offset--; + } + int finalIdx = idx; + reference.addCallback(end -> labelTable.set(finalIdx, end)); + } + instruction.withLabelTable(labelTable); + break; + } + case TRY_TABLE: + { + // labels computation + var catches = CatchOpCode.decode(baseInstruction.operands()); + var allLabels = CatchOpCode.allLabels(baseInstruction.operands()); + for (var idx = 0; idx < allLabels.size(); idx++) { + var offset = allLabels.get(idx); + ControlTree reference = currentControlFlow; + while (offset > 0) { + if (reference == null) { + throw new InvalidException("unknown label"); + } + reference = reference.parent(); + offset--; + } + int finalIdx = idx; + reference.addCallback( + end -> catches.get(finalIdx).resolvedLabel(end)); + } + instruction.withCatches(catches); + + // block start + currentControlFlow = + currentControlFlow.spawn(instructions.size(), instruction); + break; + } + case END: + { + currentControlFlow.setFinalInstructionNumber( + instructions.size(), instruction); + currentControlFlow = currentControlFlow.parent(); + + if (lastInstruction && instructions.size() > 1) { + var former = instructions.get(instructions.size() - 1); + if (former.opcode() == OpCode.END) { + instruction.withScope(former.scope().get()); + } + } + break; + } + } + if (lastInstruction && instruction.opcode() != OpCode.END) { + throw new MalformedException("END opcode expected, section size mismatch"); + } + + instructions.add(instruction); + } while (!lastInstruction); + + // unbalanced END opcodes + if (depth > 0) { + throw new MalformedException("unexpected end"); + } + + var functionBody = + new FunctionBody( + locals, + Collections.unmodifiableList( + instructions.stream() + .map(ins -> ins.build()) + .collect(Collectors.toList()))); + codeSection.addFunctionBody(functionBody); + } + + return codeSection.build(); + } + + private static DataSection parseDataSection(ByteBuffer buffer) { + + var dataSegmentCount = readVarUInt32(buffer); + DataSection.Builder dataSection = DataSection.builder(); + + for (var i = 0; i < dataSegmentCount; i++) { + var mode = readVarUInt32(buffer); + if (mode == 0) { + var offset = parseExpression(buffer); + byte[] data = new byte[(int) readVarUInt32(buffer)]; + readBytes(buffer, data); + dataSection.addDataSegment(new ActiveDataSegment(0, List.of(offset), data)); + } else if (mode == 1) { + byte[] data = new byte[(int) readVarUInt32(buffer)]; + readBytes(buffer, data); + dataSection.addDataSegment(new PassiveDataSegment(data)); + } else if (mode == 2) { + var memoryId = readVarUInt32(buffer); + var offset = parseExpression(buffer); + byte[] data = new byte[(int) readVarUInt32(buffer)]; + readBytes(buffer, data); + dataSection.addDataSegment(new ActiveDataSegment(memoryId, List.of(offset), data)); + } else { + throw new ChicoryException("Failed to parse data segment with data mode: " + mode); + } + } + + return dataSection.build(); + } + + private static DataCountSection parseDataCountSection(ByteBuffer buffer) { + var dataCount = readVarUInt32(buffer); + return DataCountSection.builder().withDataCount((int) dataCount).build(); + } + + private static TagSection parseTagSection(ByteBuffer buffer) { + var tagsCount = readVarUInt32(buffer); + var tagSection = TagSection.builder(); + for (int i = 0; i < tagsCount; i++) { + var attribute = readByte(buffer); + var typeIdx = (int) readVarUInt32(buffer); + tagSection.addTagType(new TagType(attribute, typeIdx)); + } + return tagSection.build(); + } + + private static Instruction parseInstruction(ByteBuffer buffer) { + + var address = buffer.position(); + int b = (int) readByte(buffer) & 0xff; + if (b >= 0xfc && b < 0xff) { // is multi-byte + b = (int) ((b << 8) + readVarUInt32(buffer)); + } + var op = OpCode.byOpCode(b); + if (op == null) { + throw new MalformedException("illegal opcode, op value " + String.format("%02X ", b)); + } + var signature = OpCode.signature(op); + + switch (op) { + case MEMORY_GROW: + case MEMORY_SIZE: + { + var zero = readByte(buffer); + if (zero != 0x00) { + throw new MalformedException("zero byte expected"); + } + break; + } + default: + break; + } + + // reserving an operand in those two operations to inject + // a ValType hint at validation time + switch (op) { + case DROP: + case SELECT: + return new Instruction(address, op, new long[] {0}); + } + if (signature.isEmpty()) { + return new Instruction(address, op, EMPTY_OPERANDS); + } + + var operands = new ArrayList(); + for (var sig : signature) { + switch (sig) { + case BYTE: + operands.add(Byte.toUnsignedLong(readByte(buffer))); + break; + case VARUINT: + operands.add(readVarUInt32(buffer)); + break; + case VARSINT32: + operands.add(readVarSInt32(buffer)); + break; + case VARSINT64: + operands.add(readVarSInt64(buffer)); + break; + case FLOAT64: + operands.add(readFloat64(buffer)); + break; + case FLOAT32: + operands.add(readFloat32(buffer)); + break; + case VEC_VARUINT: + { + var vcount = (int) readVarUInt32(buffer); + for (var j = 0; j < vcount; j++) { + operands.add(readVarUInt32(buffer)); + } + break; + } + case VEC_CATCH: + { + var n = readVarUInt32(buffer); + operands.add(n); + for (var j = 0; j < n; j++) { + var catchOp = readByte(buffer); + operands.add(0L | catchOp); + var catchOpcode = CatchOpCode.byOpCode(catchOp); + switch (catchOpcode) { + case CATCH: + case CATCH_REF: + operands.add(readVarUInt32(buffer)); // tag + // intentional fall-through + case CATCH_ALL: + case CATCH_ALL_REF: + operands.add(readVarUInt32(buffer)); // label + break; + } + } + break; + } + case V128: + { + byte[] bytes = new byte[16]; + for (var j = 0; j < 16; j++) { + bytes[j] = readByte(buffer); + } + for (var val : Value.bytesToVec(bytes)) { + operands.add(val); + } + break; + } + case BLOCK_TYPE: + var operand = (int) readVarUInt32(buffer); + if (ValType.ID.isValidOpcode(operand)) { + // is value type + ValType.Builder v = readValueTypeBuilderFromOpCode(buffer, operand); + operands.add(v.id()); + } else { + operands.add((long) operand); + } + break; + case VEC_VALUE_TYPE: + var vcount = (int) readVarUInt32(buffer); + for (var j = 0; j < vcount; j++) { + operands.add(readValueTypeBuilder(buffer).id()); + } + break; + } + } + var operandsArray = new long[operands.size()]; + for (var i = 0; i < operands.size(); i++) { + operandsArray[i] = operands.get(i); + } + verifyAlignment(op, operandsArray); + return new Instruction(address, op, operandsArray); + } + + private static void verifyAlignment(OpCode op, long[] operands) { + var align = -1; + switch (op) { + case I32_LOAD8_U: + case I32_LOAD8_S: + case I64_LOAD8_U: + case I64_LOAD8_S: + case I32_STORE8: + case I64_STORE8: + case V128_LOAD8_SPLAT: + case V128_STORE8_LANE: + case V128_LOAD8_LANE: + align = 8; + break; + case I32_LOAD16_U: + case I32_LOAD16_S: + case I64_LOAD16_U: + case I64_LOAD16_S: + case I32_STORE16: + case I64_STORE16: + case V128_LOAD16_SPLAT: + case V128_STORE16_LANE: + case V128_LOAD16_LANE: + align = 16; + break; + case I32_LOAD: + case F32_LOAD: + case I64_LOAD32_U: + case I64_LOAD32_S: + case I64_STORE32: + case I32_STORE: + case F32_STORE: + case V128_LOAD32_SPLAT: + case V128_STORE32_LANE: + case V128_LOAD32_LANE: + align = 32; + break; + case I64_LOAD: + case F64_LOAD: + case I64_STORE: + case F64_STORE: + case V128_LOAD8x8_S: + case V128_LOAD8x8_U: + case V128_LOAD16x4_S: + case V128_LOAD16x4_U: + case V128_LOAD32x2_S: + case V128_LOAD32x2_U: + case V128_LOAD64_SPLAT: + case V128_STORE64_LANE: + case V128_LOAD64_LANE: + align = 64; + break; + case V128_LOAD: + case V128_STORE: + align = 128; + break; + } + + if (align > 0) { + var operand0 = ((int) operands[0]); + var offset = 1 << operand0; + + if (operand0 >= align) { + throw new MalformedException("malformed memop flags"); + } else if (offset < 0 || offset > (align >> 3)) { + throw new InvalidException( + "alignment must not be larger than natural alignment (" + operand0 + ")"); + } + } + } + + private static ValType.Builder readValueTypeBuilderFromOpCode( + ByteBuffer buffer, int valueTypeOpCode) { + var builder = ValType.builder().withOpcode(valueTypeOpCode); + if (valueTypeOpCode == ValType.ID.Ref || valueTypeOpCode == ValType.ID.RefNull) { + return builder.withTypeIdx((int) readVarSInt32(buffer)); + } else { + return builder; + } + } + + private static ValType.Builder readValueTypeBuilder(ByteBuffer buffer) { + var valueTypeOpCode = (int) readVarUInt32(buffer); + + return readValueTypeBuilderFromOpCode(buffer, valueTypeOpCode); + } + + private static ValType readValueTypeFromOpCode( + ByteBuffer buffer, int valueTypeOpCode, TypeSection typeSection) { + return readValueTypeBuilderFromOpCode(buffer, valueTypeOpCode).build(typeSection::getType); + } + + private static ValType readValueType(ByteBuffer buffer, TypeSection typeSection) { + return readValueTypeBuilder(buffer).build(typeSection::getType); + } + + private static Instruction[] parseExpression(ByteBuffer buffer) { + var expr = new ArrayList(); + while (buffer.hasRemaining()) { + var i = parseInstruction(buffer); + if (i.opcode() == OpCode.END) { + return expr.toArray(new Instruction[0]); + } + expr.add(i); + } + + throw new MalformedException("illegal opcode: expected end opcode"); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/ParserListener.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/ParserListener.java new file mode 100644 index 000000000..cc821f1d7 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/ParserListener.java @@ -0,0 +1,9 @@ +package com.dylibso.chicory.wasm; + +import com.dylibso.chicory.wasm.types.Section; + +@FunctionalInterface +public interface ParserListener { + + void onSection(Section section); +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/UninstantiableException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/UninstantiableException.java new file mode 100644 index 000000000..dc8f1610f --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/UninstantiableException.java @@ -0,0 +1,15 @@ +package com.dylibso.chicory.wasm; + +public class UninstantiableException extends ChicoryException { + public UninstantiableException(String msg) { + super(msg); + } + + public UninstantiableException(Throwable cause) { + super(cause); + } + + public UninstantiableException(String msg, Throwable cause) { + super(msg, cause); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/UnlinkableException.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/UnlinkableException.java new file mode 100644 index 000000000..6c17a03e4 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/UnlinkableException.java @@ -0,0 +1,15 @@ +package com.dylibso.chicory.wasm; + +public class UnlinkableException extends ChicoryException { + public UnlinkableException(String msg) { + super(msg); + } + + public UnlinkableException(Throwable cause) { + super(cause); + } + + public UnlinkableException(String msg, Throwable cause) { + super(msg, cause); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/Validator.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/Validator.java new file mode 100644 index 000000000..134f22048 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/Validator.java @@ -0,0 +1,2236 @@ +package com.dylibso.chicory.wasm; + +import static java.util.Objects.requireNonNull; +import static java.util.stream.Collectors.joining; +import static java.util.stream.Collectors.toList; +import static java.util.stream.Collectors.toSet; + +import com.dylibso.chicory.wasm.types.ActiveDataSegment; +import com.dylibso.chicory.wasm.types.ActiveElement; +import com.dylibso.chicory.wasm.types.AnnotatedInstruction; +import com.dylibso.chicory.wasm.types.CatchOpCode; +import com.dylibso.chicory.wasm.types.DeclarativeElement; +import com.dylibso.chicory.wasm.types.Element; +import com.dylibso.chicory.wasm.types.ExternalType; +import com.dylibso.chicory.wasm.types.FunctionBody; +import com.dylibso.chicory.wasm.types.FunctionImport; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.Global; +import com.dylibso.chicory.wasm.types.GlobalImport; +import com.dylibso.chicory.wasm.types.Instruction; +import com.dylibso.chicory.wasm.types.MutabilityType; +import com.dylibso.chicory.wasm.types.OpCode; +import com.dylibso.chicory.wasm.types.Table; +import com.dylibso.chicory.wasm.types.TableImport; +import com.dylibso.chicory.wasm.types.TagImport; +import com.dylibso.chicory.wasm.types.TagSection; +import com.dylibso.chicory.wasm.types.TagType; +import com.dylibso.chicory.wasm.types.ValType; +import com.dylibso.chicory.wasm.types.Value; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Locale; +import java.util.Set; +import java.util.stream.Stream; + +// Heavily inspired by wazero +// https://github.com/tetratelabs/wazero/blob/5a8a053bff0ae795b264de9672016745cb842070/internal/wasm/func_validation.go +// control flow implementation follows: +// https://webassembly.github.io/spec/core/appendix/algorithm.html +final class Validator { + + private static boolean isNum(ValType t) { + return t.isNumeric() || t.equals(ValType.BOT); + } + + private static boolean isRef(ValType t) { + return t.isReference() || t.equals(ValType.BOT); + } + + @SuppressWarnings("PublicField") + private static class CtrlFrame { + // OpCode of the current Control Flow instruction + final OpCode opCode; + // params or inputs + final List startTypes; + // returns or outputs + final List endTypes; + // the height of the value stack before entering the current Control Flow instruction + final int height; + // the height of the init stack before entering the current Control Flow + final int initHeight; + // set after unconditional jumps + boolean unreachable; + // if there is no else, we explicit check that the enclosing IF is not returning values + boolean hasElse; + + CtrlFrame( + OpCode opCode, + List startTypes, + List endTypes, + int height, + int initHeight, + boolean unreachable, + boolean hasElse) { + this.opCode = opCode; + this.startTypes = startTypes; + this.endTypes = endTypes; + this.initHeight = initHeight; + this.height = height; + this.unreachable = unreachable; + this.hasElse = hasElse; + } + } + + private final List valTypeStack = new ArrayList<>(); + private final List ctrlFrameStack = new ArrayList<>(); + private final List initStack = new ArrayList<>(); + + private final List errors = new ArrayList<>(); + + private final WasmModule module; + private final List locals; + private final List localsInitialized; + private final List globalImports; + private final List functionImports; + private final List tableImports; + private final List tagImports; + private final int memoryImports; + private final Set declaredFunctions; + + Validator(WasmModule module) { + this.module = requireNonNull(module); + + this.locals = new ArrayList<>(); + this.localsInitialized = new ArrayList<>(); + + this.globalImports = + module.importSection().stream() + .filter(GlobalImport.class::isInstance) + .map(GlobalImport.class::cast) + .map(i -> new Global(i.type(), i.mutabilityType(), List.of())) + .collect(toList()); + + this.functionImports = + module.importSection().stream() + .filter(FunctionImport.class::isInstance) + .map(FunctionImport.class::cast) + .map(FunctionImport::typeIndex) + .collect(toList()); + + this.tableImports = + module.importSection().stream() + .filter(TableImport.class::isInstance) + .map(TableImport.class::cast) + .map(TableImport::entryType) + .collect(toList()); + + this.memoryImports = module.importSection().count(ExternalType.MEMORY); + + this.declaredFunctions = + module.elementSection().stream() + .filter(DeclarativeElement.class::isInstance) + .flatMap(element -> element.initializers().stream()) + .flatMap(this::declaredFunctions) + .collect(toSet()); + + this.tagImports = + module.importSection().stream() + .filter(TagImport.class::isInstance) + .map(TagImport.class::cast) + .map(TagImport::tagType) + .collect(toList()); + } + + private Stream declaredFunctions(List init) { + if (!init.isEmpty() && init.get(0).opcode() == OpCode.REF_FUNC) { + int idx = (int) init.get(0).operand(0); + getFunctionType(idx); + if (idx >= functionImports.size()) { + return Stream.of(idx); + } + } + return Stream.empty(); + } + + private void pushVal(ValType valType) { + valTypeStack.add(valType); + } + + private ValType popVal() { + var frame = peekCtrl(); + if (valTypeStack.size() == frame.height && frame.unreachable) { + return ValType.BOT; + } + if (valTypeStack.size() == frame.height) { + errors.add( + new InvalidException( + "type mismatch: instruction requires [i32] but stack has []")); + return ValType.BOT; + } + return valTypeStack.remove(valTypeStack.size() - 1); + } + + private ValType popVal(ValType expected) { + var actual = popVal(); + if (!ValType.matches(actual, expected) + && !actual.equals(ValType.BOT) + && !expected.equals(ValType.BOT)) { + errors.add( + new InvalidException( + "type mismatch: instruction requires [" + + expected.toString().toLowerCase(Locale.ROOT) + + "] but stack has [" + + actual.toString().toLowerCase(Locale.ROOT) + + "]")); + } + return actual; + } + + private ValType popRef() { + var actual = popVal(); + if (!isRef(actual)) { + errors.add( + new InvalidException( + "type mismatch, popRef(), expected reference type" + + " but got: " + + actual)); + } + if (actual.equals(ValType.BOT)) { + return ValType.RefBot; + } + + return actual; + } + + private void pushVals(List valTypes) { + for (var t : valTypes) { + pushVal(t); + } + } + + private List popVals(List valTypes) { + var popped = new ValType[valTypes.size()]; + for (int i = valTypes.size() - 1; i >= 0; i--) { + popped[i] = popVal(valTypes.get(i)); + } + return Arrays.asList(popped); + } + + private ValType getLocal(int idx) { + if (idx >= locals.size()) { + throw new InvalidException("unknown local " + idx); + } + if (!localsInitialized.get(idx)) { + errors.add(new InvalidException("uninitialized local: index " + idx)); + } + return getLocalType(idx); + } + + private void setLocal(int idx) { + if (idx >= locals.size()) { + throw new InvalidException("unknown local " + idx); + } + if (!localsInitialized.get(idx)) { + initStack.add(idx); + localsInitialized.set(idx, true); + } + } + + private void resetLocals(int height) { + while (initStack.size() > height) { + localsInitialized.set(initStack.remove(initStack.size() - 1), false); + } + } + + private void pushCtrl(OpCode opCode, List in, List out) { + var frame = + new CtrlFrame(opCode, in, out, valTypeStack.size(), initStack.size(), false, false); + pushCtrl(frame); + pushVals(in); + } + + private void pushCtrl(CtrlFrame frame) { + ctrlFrameStack.add(frame); + } + + private CtrlFrame popCtrl() { + if (ctrlFrameStack.isEmpty()) { + errors.add(new InvalidException("type mismatch, control frame stack empty")); + } + var frame = peekCtrl(); + popVals(frame.endTypes); + if (valTypeStack.size() != frame.height) { + errors.add(new InvalidException("type mismatch, mismatching stack height")); + } + resetLocals(frame.initHeight); + ctrlFrameStack.remove(ctrlFrameStack.size() - 1); + return frame; + } + + private CtrlFrame peekCtrl() { + return ctrlFrameStack.get(ctrlFrameStack.size() - 1); + } + + private CtrlFrame getCtrl(int n) { + return ctrlFrameStack.get(ctrlFrameStack.size() - 1 - n); + } + + private static List labelTypes(CtrlFrame frame) { + return (frame.opCode == OpCode.LOOP) ? frame.startTypes : frame.endTypes; + } + + private void resetAtStackLimit() { + var frame = peekCtrl(); + while (valTypeStack.size() > frame.height) { + valTypeStack.remove(valTypeStack.size() - 1); + } + } + + private void unreachable() { + var frame = peekCtrl(); + resetAtStackLimit(); + frame.unreachable = true; + } + + private void validateMemory(int id) { + if ((module.memorySection().isEmpty() && memoryImports == 0) || id != 0) { + throw new InvalidException("unknown memory " + id); + } + } + + private void validateMemAlign(long current, long expected) { + if (current != expected) { + throw new InvalidException( + "invalid memory alignement, current: " + current + ", expected: " + expected); + } + } + + private void validateLane(int id, int max) { + if (id < 0 || id >= max) { + throw new InvalidException("invalid lane index " + id + " max is " + max); + } + } + + private void validateDataSegment(int idx) { + if (idx < 0 || idx >= module.dataSection().dataSegmentCount()) { + throw new InvalidException("unknown data segment " + idx); + } + } + + private ValType valType(long id) { + return ValType.builder().fromId(id).build(module.typeSection()::getType); + } + + private ValType valType(int opcode, int typeIdx) { + return ValType.builder() + .withOpcode(opcode) + .withTypeIdx(typeIdx) + .build(module.typeSection()::getType); + } + + private List getReturns(AnnotatedInstruction op) { + var typeId = op.operand(0); + if (typeId == 0x40) { // epsilon + return List.of(); + } + if (ValType.isValid(typeId)) { + return List.of(valType(typeId)); + } + return getType((int) typeId).returns(); + } + + private List getParams(AnnotatedInstruction op) { + var typeId = op.operand(0); + if (typeId == 0x40) { // epsilon + return List.of(); + } + if (ValType.isValid(typeId)) { + return List.of(); + } + if (typeId >= module.typeSection().typeCount()) { + throw new MalformedException("unexpected end"); + } + return getType((int) typeId).params(); + } + + private ValType getLocalType(int idx) { + if (idx >= locals.size()) { + throw new InvalidException("unknown local " + idx); + } + return locals.get(idx); + } + + private FunctionType getType(int idx) { + if (idx < 0 || idx >= module.typeSection().typeCount()) { + throw new InvalidException("unknown type " + idx); + } + return module.typeSection().getType(idx); + } + + private Global getGlobal(int idx) { + if (idx < 0 || idx >= globalImports.size() + module.globalSection().globalCount()) { + throw new InvalidException("unknown global " + idx); + } + if (idx < globalImports.size()) { + return globalImports.get(idx); + } + return module.globalSection().getGlobal(idx - globalImports.size()); + } + + private int getFunctionType(int idx) { + if (idx < 0 || idx >= functionImports.size() + module.functionSection().functionCount()) { + throw new InvalidException("unknown function " + idx); + } + if (idx < functionImports.size()) { + return functionImports.get(idx); + } + return module.functionSection().getFunctionType(idx - functionImports.size()); + } + + private ValType getTableType(int idx) { + if (idx < 0 || idx >= tableImports.size() + module.tableSection().tableCount()) { + throw new InvalidException("unknown table " + idx); + } + if (idx < tableImports.size()) { + return tableImports.get(idx); + } + return module.tableSection().getTable(idx - tableImports.size()).elementType(); + } + + private TagType getTagType(int idx) { + var tagCount = module.tagSection().map(ts -> ts.tagCount()).orElse(0); + if (idx < 0 || idx >= tagImports.size() + tagCount) { + throw new InvalidException("unknown tag " + idx); + } + if (idx < tagImports.size()) { + return tagImports.get(idx); + } + return module.tagSection().get().getTag(idx - tagImports.size()); + } + + private Element getElement(int idx) { + if (idx < 0 || idx >= module.elementSection().elementCount()) { + throw new InvalidException("unknown elem segment " + idx); + } + return module.elementSection().getElement(idx); + } + + void validateModule() { + if (module.functionSection().functionCount() != module.codeSection().functionBodyCount()) { + throw new MalformedException("function and code section have inconsistent lengths"); + } + + if (module.dataCountSection() + .map(dcs -> dcs.dataCount() != module.dataSection().dataSegmentCount()) + .orElse(false)) { + throw new MalformedException("data count and data section have inconsistent lengths"); + } + + if (module.startSection().isPresent()) { + long index = module.startSection().get().startIndex(); + if (index < 0 || index > Integer.MAX_VALUE) { + throw new InvalidException("unknown function " + index); + } + var type = getType(getFunctionType((int) index)); + if (!type.params().isEmpty() || !type.returns().isEmpty()) { + throw new InvalidException( + "invalid start function, must have empty signature " + type); + } + } + } + + void validateData() { + // Validate offsets. + for (var ds : module.dataSection().dataSegments()) { + if (ds instanceof ActiveDataSegment) { + var ads = (ActiveDataSegment) ds; + if (ads.index() != 0) { + throw new InvalidException("unknown memory " + ads.index()); + } + validateConstantExpression(ads.offsetInstructions(), ValType.I32); + } + } + } + + void validateTypes() { + var types = module.typeSection().types(); + for (var i = 0; i < types.length; i++) { + var t = types[i]; + t.params().forEach(this::validateValueType); + t.returns().forEach(this::validateValueType); + } + } + + void validateTags() { + for (var tagType : module.tagSection().map(ts -> ts.types()).orElse(new TagType[0])) { + var type = module.typeSection().getType(tagType.typeIdx()); + if (type.returns().size() > 0) { + throw new InvalidException("non-empty tag result type index: " + tagType.typeIdx()); + } + } + } + + void validateTables() { + for (int i = 0; i < module.tableSection().tableCount(); i++) { + Table t = module.tableSection().getTable(i); + validateConstantExpression(t.initialize(), t.elementType()); + } + } + + void validateElements() { + // Validate offsets. + var totalFunctions = + module.functionSection().functionCount() + + module.importSection().stream() + .filter(i -> i.importType() == ExternalType.FUNCTION) + .count(); + for (Element el : module.elementSection().elements()) { + validateValueType(el.type()); + if (el instanceof ActiveElement) { + var ae = (ActiveElement) el; + if (!ValType.matches(ae.type(), getTableType(ae.tableIndex()))) { + throw new InvalidException( + "type mismatch, active element doesn't match table type"); + } + validateConstantExpression(ae.offset(), ValType.I32); + for (int i = 0; i < ae.initializers().size(); i++) { + var initializers = ae.initializers().get(i); + if (initializers.stream().filter(x -> x.opcode() != OpCode.END).count() != 1) { + // TODO: this indicates that error messages should be concatenated + // space for further refactoring + throw new InvalidException("type mismatch, constant expression required"); + } + for (var init : initializers) { + if (init.opcode() == OpCode.REF_FUNC) { + var idx = init.operands()[0]; + if (idx < 0 || idx >= totalFunctions) { + throw new InvalidException("unknown function " + idx); + } + } + } + validateConstantExpression( + ae.initializers().get(i), getTableType(ae.tableIndex())); + } + } else if (el instanceof DeclarativeElement) { + for (var init : el.initializers()) { + if (init.stream().filter(x -> x.opcode() != OpCode.END).count() != 1) { + throw new InvalidException("type mismatch, constant expression required"); + } + } + } + } + } + + void validateGlobals() { + for (Global g : module.globalSection().globals()) { + validateConstantExpression(g.initInstructions(), g.valueType()); + } + } + + private void validateConstantExpression( + List expr, ValType expectedType) { + validateValueType(expectedType); + int allFuncCount = this.functionImports.size() + module.functionSection().functionCount(); + var valTypeStack = new ArrayDeque(); + for (var instruction : expr) { + switch (instruction.opcode()) { + case I32_CONST: + valTypeStack.push(ValType.I32); + break; + case I32_ADD: + case I32_SUB: + case I32_MUL: + valTypeStack.pop(); + valTypeStack.pop(); + valTypeStack.push(ValType.I32); + break; + case I64_CONST: + valTypeStack.push(ValType.I64); + break; + case I64_ADD: + case I64_SUB: + case I64_MUL: + valTypeStack.pop(); + valTypeStack.pop(); + valTypeStack.push(ValType.I64); + break; + case F32_CONST: + valTypeStack.push(ValType.F32); + break; + case F64_CONST: + valTypeStack.push(ValType.F64); + break; + case V128_CONST: + valTypeStack.push(ValType.V128); + break; + case REF_NULL: + { + int operand = (int) instruction.operand(0); + valTypeStack.push(valType(ValType.ID.RefNull, operand)); + break; + } + case REF_FUNC: + { + int idx = (int) instruction.operand(0); + valTypeStack.push(valType(ValType.ID.Ref, getFunctionType(idx))); + if (idx < 0 || idx > allFuncCount) { + throw new InvalidException("unknown function " + idx); + } + break; + } + case GLOBAL_GET: + { + var idx = (int) instruction.operand(0); + if (idx < globalImports.size()) { + var global = globalImports.get(idx); + if (global.mutabilityType() != MutabilityType.Const) { + throw new InvalidException( + "constant expression required, initializer expression" + + " cannot reference a mutable global"); + } + valTypeStack.push(global.valueType()); + } else { + throw new InvalidException( + "unknown global " + + idx + + ", initializer expression can only reference" + + " an imported global"); + } + break; + } + case END: + break; + default: + throw new InvalidException( + "constant expression required, but non-constant instruction" + + " encountered: " + + instruction); + } + } + + if (valTypeStack.size() < 1) { + throw new InvalidException("type mismatch, no constant expressions found"); + } + if (valTypeStack.size() != 1) { + throw new InvalidException( + "type mismatch, values remaining on the stack after evaluation"); + } else { + var exprType = valTypeStack.pop(); + if (exprType != null && !ValType.matches(exprType, expectedType)) { + throw new InvalidException("type mismatch"); + } + } + } + + void validateFunctions() { + for (var i = 0; i < module.codeSection().functionBodyCount(); i++) { + var body = module.codeSection().getFunctionBody(i); + var idx = functionImports.size() + i; + var type = getType(getFunctionType(idx)); + validateFunction(idx, body, type); + } + } + + private static int[] typesWithDefaultValue = + new int[] { + ValType.ID.F64, + ValType.ID.F64, + ValType.ID.F32, + ValType.ID.I64, + ValType.ID.I32, + ValType.ID.V128, + ValType.ID.RefNull + }; + + private static boolean hasDefaultValue(ValType t) { + for (var t2 : typesWithDefaultValue) { + if (t.opcode() == t2) { + return true; + } + } + + return false; + } + + private void validateValueType(ValType valueType) { + if (valueType.isReference() && valueType.typeIdx() >= 0) { + int idx = valueType.typeIdx(); + if (idx >= module.typeSection().typeCount()) { + throw new InvalidException("unknown type " + idx); + } + } + } + + @SuppressWarnings("UnnecessaryCodeBlock") + void validateFunction(int funcIdx, FunctionBody body, FunctionType functionType) { + valTypeStack.clear(); + locals.clear(); + localsInitialized.clear(); + + functionType + .params() + .forEach( + t -> { + validateValueType(t); + locals.add(t); + localsInitialized.add(true); + }); + + body.localTypes() + .forEach( + t -> { + validateValueType(t); + locals.add(t); + localsInitialized.add(hasDefaultValue(t)); + }); + + functionType.returns().forEach(this::validateValueType); + + pushCtrl(null, new ArrayList<>(), functionType.returns()); + + for (var i = 0; i < body.instructions().size(); i++) { + var op = body.instructions().get(i); + + // control flow instructions handling + switch (op.opcode()) { + case UNREACHABLE: + unreachable(); + break; + case TRY_TABLE: + { + var t1 = getParams(op); + var t2 = getReturns(op); + popVals(t1); + // and now the catches + var catches = CatchOpCode.decode(op.operands()); + + for (int idx = 0; idx < catches.size(); idx++) { + var currentCatch = catches.get(idx); + if (ctrlFrameStack.size() < currentCatch.label()) { + throw new InvalidException("something something"); + } + // push_ctrl(catch, [], label_types(ctrls[handler.label])) + // using THROW instead of CATCH ... doesn't matter as it's removed right + // after + pushCtrl( + OpCode.THROW, + List.of(), + labelTypes(getCtrl(currentCatch.label()))); + switch (currentCatch.opcode()) { + case CATCH: + { + var tagType = + module.typeSection() + .getType( + getTagType(currentCatch.tag()) + .typeIdx()); + pushVals(tagType.params()); + break; + } + case CATCH_REF: + { + var tagType = + module.typeSection() + .getType( + getTagType(currentCatch.tag()) + .typeIdx()); + pushVals(tagType.params()); + pushVal(ValType.ExnRef); + break; + } + case CATCH_ALL: + break; + case CATCH_ALL_REF: + pushVal(ValType.ExnRef); + break; + } + popCtrl(); + } + pushCtrl(op.opcode(), t1, t2); + break; + } + case THROW: + { + var tagNumber = (int) op.operand(0); + if ((tagImports.size() + + module.tagSection().map(TagSection::tagCount).orElse(0)) + <= tagNumber) { + throw new InvalidException("unknown tag " + tagNumber); + } + var type = module.typeSection().getType(getTagType(tagNumber).typeIdx()); + popVals(type.params()); + assert (type.returns().size() == 0); + unreachable(); + break; + } + case THROW_REF: + { + popVal(ValType.ExnRef); + unreachable(); + break; + } + case IF: + popVal(ValType.I32); + // fallthrough + case LOOP: + // t1* -> t2* + // fallthrough + case BLOCK: + { + var t1 = getParams(op); + var t2 = getReturns(op); + t2.forEach(this::validateValueType); + popVals(t1); + pushCtrl(op.opcode(), t1, t2); + break; + } + case END: + { + var frame = popCtrl(); + if (frame.opCode == OpCode.IF + && !frame.hasElse + && frame.startTypes.size() != frame.endTypes.size()) { + throw new InvalidException("type mismatch, unbalanced if branches"); + } + pushVals(frame.endTypes); + break; + } + case ELSE: + { + var frame = popCtrl(); + if (frame.opCode != OpCode.IF) { + throw new InvalidException("else doesn't belong to if"); + } + pushCtrl(op.opcode(), frame.startTypes, frame.endTypes); + peekCtrl().hasElse = true; + break; + } + case BR: + { + var n = (int) op.operand(0); + popVals(labelTypes(getCtrl(n))); + unreachable(); + break; + } + case BR_IF: + { + popVal(ValType.I32); + var n = (int) op.operand(0); + var labelTypes = labelTypes(getCtrl(n)); + popVals(labelTypes); + pushVals(labelTypes); + break; + } + case BR_TABLE: + { + popVal(ValType.I32); + var m = (int) op.operand(op.operandCount() - 1); + if ((ctrlFrameStack.size() - 1 - m) < 0) { + throw new InvalidException("unknown label " + m); + } + var defaultBranchLabelTypes = labelTypes(getCtrl(m)); + var arity = defaultBranchLabelTypes.size(); + for (var idx = 0; idx < op.operandCount() - 1; idx++) { + var n = (int) op.operand(idx); + CtrlFrame ctrlFrame; + try { + ctrlFrame = getCtrl(n); + } catch (IndexOutOfBoundsException e) { + throw new InvalidException("unknown label", e); + } + var labelTypes = labelTypes(ctrlFrame); + if (labelTypes.size() != arity) { + throw new InvalidException( + "type mismatch, mismatched arity in BR_TABLE for label " + + n); + } + pushVals(popVals(labelTypes)); + } + popVals(defaultBranchLabelTypes); + unreachable(); + break; + } + case BR_ON_NULL: + { + var n = (int) op.operand(0); + var rt = popRef(); + var labelTypes = labelTypes(getCtrl(n)); + popVals(labelTypes); + pushVals(labelTypes); + pushVal(valType(ValType.ID.Ref, rt.typeIdx())); + break; + } + case BR_ON_NON_NULL: + { + var n = (int) op.operand(0); + var rt = popRef(); + pushVal(valType(ValType.ID.Ref, rt.typeIdx())); + var labelTypes = labelTypes(getCtrl(n)); + popVals(labelTypes); + pushVals(labelTypes); + popVal(); + break; + } + case RETURN: + VALIDATE_RETURN(); + break; + case RETURN_CALL: + VALIDATE_CALL((int) op.operand(0), true); + VALIDATE_RETURN(); + break; + case RETURN_CALL_INDIRECT: + VALIDATE_CALL_INDIRECT(op.operand(0), (int) op.operand(1), true); + VALIDATE_RETURN(); + break; + case RETURN_CALL_REF: + VALIDATE_CALL_REF((int) op.operand(0), true); + VALIDATE_RETURN(); + break; + default: + break; + } + + switch (op.opcode()) { + case MEMORY_COPY: + validateMemory((int) op.operand(0)); + validateMemory((int) op.operand(1)); + break; + case MEMORY_FILL: + validateMemory((int) op.operand(0)); + break; + case MEMORY_INIT: + validateMemory((int) op.operand(1)); + validateDataSegment((int) op.operand(0)); + break; + case MEMORY_SIZE: + case MEMORY_GROW: + case I32_LOAD: + case I32_LOAD8_U: + case I32_ATOMIC_LOAD8_U: + case I32_LOAD8_S: + case I32_LOAD16_U: + case I32_ATOMIC_LOAD16_U: + case I32_LOAD16_S: + case I64_LOAD: + case I64_LOAD8_S: + case I64_LOAD8_U: + case I64_ATOMIC_LOAD8_U: + case I64_ATOMIC_LOAD16_U: + case I64_LOAD16_S: + case I64_LOAD16_U: + case I64_LOAD32_S: + case I64_LOAD32_U: + case I64_ATOMIC_LOAD32_U: + case F32_LOAD: + case F64_LOAD: + case I32_STORE: + case I32_ATOMIC_STORE: + case I32_STORE8: + case I32_ATOMIC_STORE8: + case I32_STORE16: + case I32_ATOMIC_STORE16: + case I32_ATOMIC_RMW_ADD: + case I32_ATOMIC_RMW_CMPXCHG: + case I32_ATOMIC_RMW8_CMPXCHG_U: + case I32_ATOMIC_RMW16_CMPXCHG_U: + case I64_ATOMIC_RMW_CMPXCHG: + case I64_ATOMIC_RMW8_CMPXCHG_U: + case I64_ATOMIC_RMW16_CMPXCHG_U: + case I64_ATOMIC_RMW32_CMPXCHG_U: + case I32_ATOMIC_RMW_XCHG: + case I32_ATOMIC_RMW_OR: + case I32_ATOMIC_RMW_XOR: + case I32_ATOMIC_RMW_SUB: + case I32_ATOMIC_RMW_AND: + case I32_ATOMIC_RMW8_ADD_U: + case I32_ATOMIC_RMW8_XCHG_U: + case I32_ATOMIC_RMW8_OR_U: + case I32_ATOMIC_RMW8_XOR_U: + case I32_ATOMIC_RMW8_AND_U: + case I32_ATOMIC_RMW8_SUB_U: + case I32_ATOMIC_RMW16_ADD_U: + case I32_ATOMIC_RMW16_XCHG_U: + case I32_ATOMIC_RMW16_OR_U: + case I32_ATOMIC_RMW16_XOR_U: + case I32_ATOMIC_RMW16_AND_U: + case I32_ATOMIC_RMW16_SUB_U: + case I64_STORE: + case I64_ATOMIC_STORE: + case I64_STORE8: + case I64_ATOMIC_STORE8: + case I64_STORE16: + case I64_ATOMIC_STORE16: + case I64_STORE32: + case I64_ATOMIC_STORE32: + case F32_STORE: + case F64_STORE: + case I64_ATOMIC_RMW_ADD: + case I64_ATOMIC_RMW_XCHG: + case I64_ATOMIC_RMW_OR: + case I64_ATOMIC_RMW_XOR: + case I64_ATOMIC_RMW_SUB: + case I64_ATOMIC_RMW_AND: + case I64_ATOMIC_RMW8_ADD_U: + case I64_ATOMIC_RMW8_XCHG_U: + case I64_ATOMIC_RMW8_OR_U: + case I64_ATOMIC_RMW8_XOR_U: + case I64_ATOMIC_RMW8_AND_U: + case I64_ATOMIC_RMW8_SUB_U: + case I64_ATOMIC_RMW16_ADD_U: + case I64_ATOMIC_RMW16_XCHG_U: + case I64_ATOMIC_RMW16_OR_U: + case I64_ATOMIC_RMW16_XOR_U: + case I64_ATOMIC_RMW16_AND_U: + case I64_ATOMIC_RMW16_SUB_U: + case I64_ATOMIC_RMW32_ADD_U: + case I64_ATOMIC_RMW32_XCHG_U: + case I64_ATOMIC_RMW32_OR_U: + case I64_ATOMIC_RMW32_XOR_U: + case I64_ATOMIC_RMW32_AND_U: + case I64_ATOMIC_RMW32_SUB_U: + case V128_STORE: + case MEM_ATOMIC_NOTIFY: + case MEM_ATOMIC_WAIT32: + case MEM_ATOMIC_WAIT64: + case I32_ATOMIC_LOAD: + case I64_ATOMIC_LOAD: + validateMemory(0); + break; + default: + break; + } + + switch (op.opcode()) { + case ATOMIC_FENCE: + case I32_ATOMIC_STORE8: + case I64_ATOMIC_STORE8: + case I32_ATOMIC_LOAD8_U: + case I64_ATOMIC_LOAD8_U: + case I32_ATOMIC_RMW8_ADD_U: + case I32_ATOMIC_RMW8_XCHG_U: + case I32_ATOMIC_RMW8_OR_U: + case I32_ATOMIC_RMW8_XOR_U: + case I32_ATOMIC_RMW8_AND_U: + case I32_ATOMIC_RMW8_SUB_U: + case I64_ATOMIC_RMW8_ADD_U: + case I64_ATOMIC_RMW8_XCHG_U: + case I64_ATOMIC_RMW8_OR_U: + case I64_ATOMIC_RMW8_XOR_U: + case I64_ATOMIC_RMW8_AND_U: + case I64_ATOMIC_RMW8_SUB_U: + case I32_ATOMIC_RMW8_CMPXCHG_U: + case I64_ATOMIC_RMW8_CMPXCHG_U: + validateMemAlign(op.operand(0), 0x00); + break; + case I32_ATOMIC_STORE16: + case I64_ATOMIC_STORE16: + case I32_ATOMIC_LOAD16_U: + case I64_ATOMIC_LOAD16_U: + case I32_ATOMIC_RMW16_ADD_U: + case I32_ATOMIC_RMW16_XCHG_U: + case I32_ATOMIC_RMW16_OR_U: + case I32_ATOMIC_RMW16_XOR_U: + case I32_ATOMIC_RMW16_AND_U: + case I32_ATOMIC_RMW16_SUB_U: + case I64_ATOMIC_RMW16_ADD_U: + case I64_ATOMIC_RMW16_XCHG_U: + case I64_ATOMIC_RMW16_OR_U: + case I64_ATOMIC_RMW16_XOR_U: + case I64_ATOMIC_RMW16_AND_U: + case I64_ATOMIC_RMW16_SUB_U: + case I32_ATOMIC_RMW16_CMPXCHG_U: + case I64_ATOMIC_RMW16_CMPXCHG_U: + validateMemAlign(op.operand(0), 0x01); + break; + case I32_ATOMIC_STORE: + case I64_ATOMIC_STORE32: + case I32_ATOMIC_LOAD: + case I64_ATOMIC_LOAD32_U: + case I32_ATOMIC_RMW_ADD: + case I32_ATOMIC_RMW_XCHG: + case I32_ATOMIC_RMW_OR: + case I32_ATOMIC_RMW_XOR: + case I32_ATOMIC_RMW_SUB: + case I32_ATOMIC_RMW_AND: + case I64_ATOMIC_RMW32_ADD_U: + case I64_ATOMIC_RMW32_XCHG_U: + case I64_ATOMIC_RMW32_OR_U: + case I64_ATOMIC_RMW32_XOR_U: + case I64_ATOMIC_RMW32_AND_U: + case I64_ATOMIC_RMW32_SUB_U: + case I32_ATOMIC_RMW_CMPXCHG: + case I64_ATOMIC_RMW32_CMPXCHG_U: + case MEM_ATOMIC_NOTIFY: + case MEM_ATOMIC_WAIT32: + validateMemAlign(op.operand(0), 0x02); + break; + case I64_ATOMIC_STORE: + case I64_ATOMIC_LOAD: + case I64_ATOMIC_RMW_ADD: + case I64_ATOMIC_RMW_XCHG: + case I64_ATOMIC_RMW_OR: + case I64_ATOMIC_RMW_XOR: + case I64_ATOMIC_RMW_SUB: + case I64_ATOMIC_RMW_AND: + case I64_ATOMIC_RMW_CMPXCHG: + case MEM_ATOMIC_WAIT64: + validateMemAlign(op.operand(0), 0x03); + break; + } + + switch (op.opcode()) { + case V128_LOAD8_LANE: + case V128_STORE8_LANE: + validateLane((int) op.operand(2), 16); + break; + case V128_LOAD16_LANE: + case V128_STORE16_LANE: + validateLane((int) op.operand(2), 8); + break; + case V128_LOAD32_LANE: + case V128_STORE32_LANE: + validateLane((int) op.operand(2), 4); + break; + case V128_LOAD64_LANE: + case V128_STORE64_LANE: + validateLane((int) op.operand(2), 2); + break; + case I8x16_REPLACE_LANE: + case I8x16_EXTRACT_LANE_S: + case I8x16_EXTRACT_LANE_U: + validateLane((int) op.operand(0), 16); + break; + case I16x8_REPLACE_LANE: + case I16x8_EXTRACT_LANE_S: + case I16x8_EXTRACT_LANE_U: + validateLane((int) op.operand(0), 8); + break; + case I32x4_REPLACE_LANE: + case F32x4_REPLACE_LANE: + case I32x4_EXTRACT_LANE: + case F32x4_EXTRACT_LANE: + validateLane((int) op.operand(0), 4); + break; + case I64x2_REPLACE_LANE: + case F64x2_REPLACE_LANE: + case I64x2_EXTRACT_LANE: + case F64x2_EXTRACT_LANE: + validateLane((int) op.operand(0), 2); + break; + case I8x16_SHUFFLE: + var operands = Value.vecTo8(new long[] {op.operand(0), op.operand(1)}); + for (int j = 0; j < 16; j++) { + validateLane(operands[j], 32); + } + break; + default: + break; + } + + switch (op.opcode()) { + case NOP: + case UNREACHABLE: + case THROW: + case THROW_REF: + case TRY_TABLE: + case LOOP: + case BLOCK: + case IF: + case ELSE: + case RETURN: + case RETURN_CALL: + case RETURN_CALL_INDIRECT: + case RETURN_CALL_REF: + case BR_IF: + case BR_TABLE: + case BR: + case BR_ON_NULL: + case BR_ON_NON_NULL: + case END: + case ATOMIC_FENCE: + break; + case DATA_DROP: + { + validateDataSegment((int) op.operand(0)); + break; + } + case DROP: + { + var t = popVal(); + + // setting the type hint + if (t.opcode() == ValType.ID.V128) { + op.setOperand(0, ValType.ID.V128); + } + + break; + } + case MEM_ATOMIC_NOTIFY: + { + popVal(ValType.I32); + popVal(ValType.I32); + pushVal(ValType.I32); + break; + } + case MEM_ATOMIC_WAIT32: + { + popVal(ValType.I64); + popVal(ValType.I32); + popVal(ValType.I32); + pushVal(ValType.I32); + break; + } + case MEM_ATOMIC_WAIT64: + { + popVal(ValType.I64); + popVal(ValType.I64); + popVal(ValType.I32); + pushVal(ValType.I32); + break; + } + case I32_STORE: + case I32_ATOMIC_STORE: + case I32_STORE8: + case I32_ATOMIC_STORE8: + case I32_STORE16: + case I32_ATOMIC_STORE16: + { + popVal(ValType.I32); + popVal(ValType.I32); + break; + } + case I32_LOAD: + case I32_LOAD8_U: + case I32_ATOMIC_LOAD8_U: + case I32_LOAD8_S: + case I32_LOAD16_U: + case I32_ATOMIC_LOAD16_U: + case I32_LOAD16_S: + case I32_CLZ: + case I32_CTZ: + case I32_POPCNT: + case I32_EXTEND_8_S: + case I32_EXTEND_16_S: + case I32_EQZ: + case MEMORY_GROW: + case I32_ATOMIC_LOAD: + { + popVal(ValType.I32); + pushVal(ValType.I32); + break; + } + case TABLE_SIZE: + case I32_CONST: + case MEMORY_SIZE: + { + pushVal(ValType.I32); + break; + } + case I32_ATOMIC_RMW_CMPXCHG: + case I32_ATOMIC_RMW8_CMPXCHG_U: + case I32_ATOMIC_RMW16_CMPXCHG_U: + { + popVal(ValType.I32); + popVal(ValType.I32); + popVal(ValType.I32); + pushVal(ValType.I32); + break; + } + case I64_ATOMIC_RMW_CMPXCHG: + case I64_ATOMIC_RMW8_CMPXCHG_U: + case I64_ATOMIC_RMW16_CMPXCHG_U: + case I64_ATOMIC_RMW32_CMPXCHG_U: + { + popVal(ValType.I64); + popVal(ValType.I64); + popVal(ValType.I32); + pushVal(ValType.I64); + break; + } + case I32_ADD: + case I32_ATOMIC_RMW_ADD: + case I32_ATOMIC_RMW_XCHG: + case I32_ATOMIC_RMW_OR: + case I32_ATOMIC_RMW_XOR: + case I32_ATOMIC_RMW_SUB: + case I32_ATOMIC_RMW_AND: + case I32_SUB: + case I32_MUL: + case I32_DIV_S: + case I32_DIV_U: + case I32_REM_S: + case I32_REM_U: + case I32_AND: + case I32_OR: + case I32_XOR: + case I32_EQ: + case I32_NE: + case I32_LT_S: + case I32_LT_U: + case I32_LE_S: + case I32_LE_U: + case I32_GT_S: + case I32_GT_U: + case I32_GE_S: + case I32_GE_U: + case I32_SHL: + case I32_SHR_U: + case I32_SHR_S: + case I32_ROTL: + case I32_ROTR: + case I32_ATOMIC_RMW8_ADD_U: + case I32_ATOMIC_RMW8_XCHG_U: + case I32_ATOMIC_RMW8_OR_U: + case I32_ATOMIC_RMW8_XOR_U: + case I32_ATOMIC_RMW8_AND_U: + case I32_ATOMIC_RMW8_SUB_U: + case I32_ATOMIC_RMW16_ADD_U: + case I32_ATOMIC_RMW16_XCHG_U: + case I32_ATOMIC_RMW16_OR_U: + case I32_ATOMIC_RMW16_XOR_U: + case I32_ATOMIC_RMW16_AND_U: + case I32_ATOMIC_RMW16_SUB_U: + { + popVal(ValType.I32); + popVal(ValType.I32); + pushVal(ValType.I32); + break; + } + case I32_WRAP_I64: + case I64_EQZ: + { + popVal(ValType.I64); + pushVal(ValType.I32); + break; + } + case I32_TRUNC_F32_S: + case I32_TRUNC_F32_U: + case I32_TRUNC_SAT_F32_S: + case I32_TRUNC_SAT_F32_U: + case I32_REINTERPRET_F32: + { + popVal(ValType.F32); + pushVal(ValType.I32); + break; + } + case I32_TRUNC_F64_S: + case I32_TRUNC_F64_U: + case I32_TRUNC_SAT_F64_S: + case I32_TRUNC_SAT_F64_U: + { + popVal(ValType.F64); + pushVal(ValType.I32); + break; + } + case I64_LOAD: + case I64_LOAD8_S: + case I64_LOAD8_U: + case I64_ATOMIC_LOAD8_U: + case I64_LOAD16_S: + case I64_LOAD16_U: + case I64_ATOMIC_LOAD16_U: + case I64_LOAD32_S: + case I64_LOAD32_U: + case I64_ATOMIC_LOAD32_U: + case I64_EXTEND_I32_U: + case I64_EXTEND_I32_S: + case I64_ATOMIC_LOAD: + { + popVal(ValType.I32); + pushVal(ValType.I64); + break; + } + case I64_ATOMIC_RMW_ADD: + case I64_ATOMIC_RMW_XCHG: + case I64_ATOMIC_RMW_OR: + case I64_ATOMIC_RMW_XOR: + case I64_ATOMIC_RMW_SUB: + case I64_ATOMIC_RMW_AND: + case I64_ATOMIC_RMW8_ADD_U: + case I64_ATOMIC_RMW8_XCHG_U: + case I64_ATOMIC_RMW8_OR_U: + case I64_ATOMIC_RMW8_XOR_U: + case I64_ATOMIC_RMW8_AND_U: + case I64_ATOMIC_RMW8_SUB_U: + case I64_ATOMIC_RMW16_ADD_U: + case I64_ATOMIC_RMW16_XCHG_U: + case I64_ATOMIC_RMW16_OR_U: + case I64_ATOMIC_RMW16_XOR_U: + case I64_ATOMIC_RMW16_AND_U: + case I64_ATOMIC_RMW16_SUB_U: + case I64_ATOMIC_RMW32_ADD_U: + case I64_ATOMIC_RMW32_XCHG_U: + case I64_ATOMIC_RMW32_OR_U: + case I64_ATOMIC_RMW32_XOR_U: + case I64_ATOMIC_RMW32_AND_U: + case I64_ATOMIC_RMW32_SUB_U: + { + popVal(ValType.I64); + popVal(ValType.I32); + pushVal(ValType.I64); + break; + } + case I64_CONST: + { + pushVal(ValType.I64); + break; + } + case I64_STORE: + case I64_ATOMIC_STORE: + case I64_STORE8: + case I64_ATOMIC_STORE8: + case I64_STORE16: + case I64_ATOMIC_STORE16: + case I64_STORE32: + case I64_ATOMIC_STORE32: + { + popVal(ValType.I64); + popVal(ValType.I32); + break; + } + case I64_ADD: + case I64_SUB: + case I64_MUL: + case I64_DIV_S: + case I64_DIV_U: + case I64_REM_S: + case I64_REM_U: + case I64_AND: + case I64_OR: + case I64_XOR: + case I64_SHL: + case I64_SHR_U: + case I64_SHR_S: + case I64_ROTL: + case I64_ROTR: + { + popVal(ValType.I64); + popVal(ValType.I64); + pushVal(ValType.I64); + break; + } + case I64_EQ: + case I64_NE: + case I64_LT_S: + case I64_LT_U: + case I64_LE_S: + case I64_LE_U: + case I64_GT_S: + case I64_GT_U: + case I64_GE_S: + case I64_GE_U: + { + popVal(ValType.I64); + popVal(ValType.I64); + pushVal(ValType.I32); + break; + } + case I64_CLZ: + case I64_CTZ: + case I64_POPCNT: + case I64_EXTEND_8_S: + case I64_EXTEND_16_S: + case I64_EXTEND_32_S: + { + popVal(ValType.I64); + pushVal(ValType.I64); + break; + } + case I64_REINTERPRET_F64: + case I64_TRUNC_F64_S: + case I64_TRUNC_F64_U: + case I64_TRUNC_SAT_F64_S: + case I64_TRUNC_SAT_F64_U: + { + popVal(ValType.F64); + pushVal(ValType.I64); + break; + } + case I64_TRUNC_F32_S: + case I64_TRUNC_F32_U: + case I64_TRUNC_SAT_F32_S: + case I64_TRUNC_SAT_F32_U: + { + popVal(ValType.F32); + pushVal(ValType.I64); + break; + } + case F32_STORE: + { + popVal(ValType.F32); + popVal(ValType.I32); + break; + } + case F32_CONST: + { + pushVal(ValType.F32); + break; + } + case F32_LOAD: + case F32_CONVERT_I32_S: + case F32_CONVERT_I32_U: + case F32_REINTERPRET_I32: + { + popVal(ValType.I32); + pushVal(ValType.F32); + break; + } + case F32_CONVERT_I64_S: + case F32_CONVERT_I64_U: + { + popVal(ValType.I64); + pushVal(ValType.F32); + break; + } + case F64_LOAD: + case F64_CONVERT_I32_S: + case F64_CONVERT_I32_U: + { + popVal(ValType.I32); + pushVal(ValType.F64); + break; + } + case F64_CONVERT_I64_S: + case F64_CONVERT_I64_U: + case F64_REINTERPRET_I64: + { + popVal(ValType.I64); + pushVal(ValType.F64); + break; + } + case F64_PROMOTE_F32: + { + popVal(ValType.F32); + pushVal(ValType.F64); + break; + } + case F32_DEMOTE_F64: + { + popVal(ValType.F64); + pushVal(ValType.F32); + break; + } + case F32_SQRT: + case F32_ABS: + case F32_NEG: + case F32_CEIL: + case F32_FLOOR: + case F32_TRUNC: + case F32_NEAREST: + { + popVal(ValType.F32); + pushVal(ValType.F32); + break; + } + case F32_ADD: + case F32_SUB: + case F32_MUL: + case F32_DIV: + case F32_MIN: + case F32_MAX: + case F32_COPYSIGN: + { + popVal(ValType.F32); + popVal(ValType.F32); + pushVal(ValType.F32); + break; + } + case F32_EQ: + case F32_NE: + case F32_LT: + case F32_LE: + case F32_GT: + case F32_GE: + { + popVal(ValType.F32); + popVal(ValType.F32); + pushVal(ValType.I32); + break; + } + case F64_STORE: + { + popVal(ValType.F64); + popVal(ValType.I32); + break; + } + case F64_CONST: + { + pushVal(ValType.F64); + break; + } + case F64_SQRT: + case F64_ABS: + case F64_NEG: + case F64_CEIL: + case F64_FLOOR: + case F64_TRUNC: + case F64_NEAREST: + { + popVal(ValType.F64); + pushVal(ValType.F64); + break; + } + case F64_ADD: + case F64_SUB: + case F64_MUL: + case F64_DIV: + case F64_MIN: + case F64_MAX: + case F64_COPYSIGN: + { + popVal(ValType.F64); + popVal(ValType.F64); + pushVal(ValType.F64); + break; + } + case F64_EQ: + case F64_NE: + case F64_LT: + case F64_LE: + case F64_GT: + case F64_GE: + { + popVal(ValType.F64); + popVal(ValType.F64); + pushVal(ValType.I32); + break; + } + case LOCAL_SET: + { + var index = (int) op.operand(0); + popVal(getLocalType(index)); + setLocal(index); + break; + } + case LOCAL_GET: + { + var index = (int) op.operand(0); + getLocal(index); + pushVal(getLocalType(index)); + break; + } + case LOCAL_TEE: + { + var index = (int) op.operand(0); + ValType actualType = popVal(); + setLocal(index); + ValType localType = getLocalType(index); + if (!ValType.matches(actualType, localType)) { + throw new InvalidException( + "type mismatch: local_tee: " + actualType + " " + localType); + } + pushVal(localType); + break; + } + case GLOBAL_GET: + { + var global = getGlobal((int) op.operand(0)); + pushVal(global.valueType()); + break; + } + case GLOBAL_SET: + { + var global = getGlobal((int) op.operand(0)); + if (global.mutabilityType() == MutabilityType.Const) { + // global.wast in the origin spec and function references + // have exact same test that exact two different errors + // TOOD: figure out which one + throw new InvalidException("global is immutable, immutable global"); + } + popVal(global.valueType()); + break; + } + case CALL: + VALIDATE_CALL((int) op.operand(0), false); + break; + case CALL_INDIRECT: + VALIDATE_CALL_INDIRECT(op.operand(0), (int) op.operand(1), false); + break; + case CALL_REF: + VALIDATE_CALL_REF((int) op.operand(0), false); + break; + case REF_NULL: + { + int operand = (int) op.operand(0); + ValType type = valType(ValType.ID.RefNull, operand); + pushVal(type); + break; + } + case REF_IS_NULL: + { + popRef(); + pushVal(ValType.I32); + break; + } + case REF_AS_NON_NULL: + { + var rt = popRef(); + pushVal(valType(ValType.ID.Ref, rt.typeIdx())); + break; + } + case REF_FUNC: + { + var idx = (int) op.operand(0); + if (idx == funcIdx // reference to self + && !declaredFunctions.contains(idx)) { + throw new InvalidException("undeclared function reference"); + } + pushVal(valType(ValType.ID.Ref, getFunctionType(idx))); + break; + } + case SELECT: + { + popVal(ValType.I32); + var t1 = popVal(); + var t2 = popVal(); + + // setting the type hint + if ((t1.opcode() == ValType.ID.V128 && t2.opcode() == ValType.ID.V128) + || (t1.opcode() == ValType.ID.V128 && t2.opcode() == ValType.ID.BOT) + || (t1.opcode() == ValType.ID.BOT + && t2.opcode() == ValType.ID.V128)) { + op.setOperand(0, ValType.ID.V128); + pushVal(ValType.V128); + break; + } + + if (!(isNum(t1) && isNum(t2))) { + throw new InvalidException( + "type mismatch: select should have numeric arguments but they" + + " are " + + t1 + + " " + + t2); + } + if (!t1.equals(t2) && !t1.equals(ValType.BOT) && !t2.equals(ValType.BOT)) { + throw new InvalidException( + "type mismatch, in SELECT t1: " + t1 + ", t2: " + t2); + } + if (t1.equals(ValType.BOT)) { + pushVal(t2); + } else { + pushVal(t1); + } + break; + } + case SELECT_T: + { + popVal(ValType.I32); + if (op.operands().length <= 0 || op.operands().length > 1) { + throw new InvalidException("invalid result arity"); + } + var t = valType(op.operand(0)); + validateValueType(t); + popVal(t); + popVal(t); + pushVal(t); + break; + } + case TABLE_COPY: + { + var table1 = getTableType((int) op.operand(1)); + var table2 = getTableType((int) op.operand(0)); + + if (!ValType.matches(table1, table2)) { + throw new InvalidException( + "type mismatch, table 1 type: " + + table1 + + ", table 2 type: " + + table2); + } + + popVal(ValType.I32); + popVal(ValType.I32); + popVal(ValType.I32); + break; + } + case TABLE_INIT: + { + var table = getTableType((int) op.operand(1)); + var elemIdx = (int) op.operand(0); + var elem = getElement(elemIdx); + + if (!ValType.matches(elem.type(), table)) { + throw new InvalidException( + "type mismatch, table type: " + + table + + ", elem type: " + + elem.type()); + } + + popVal(ValType.I32); + popVal(ValType.I32); + popVal(ValType.I32); + break; + } + case MEMORY_COPY: + case MEMORY_FILL: + case MEMORY_INIT: + { + popVal(ValType.I32); + popVal(ValType.I32); + popVal(ValType.I32); + break; + } + case TABLE_FILL: + { + popVal(ValType.I32); + popVal(getTableType((int) op.operand(0))); + popVal(ValType.I32); + break; + } + case TABLE_GET: + { + popVal(ValType.I32); + pushVal(getTableType((int) op.operand(0))); + break; + } + case TABLE_SET: + { + popVal(getTableType((int) op.operand(0))); + popVal(ValType.I32); + break; + } + case TABLE_GROW: + { + popVal(ValType.I32); + popVal(getTableType((int) op.operand(0))); + pushVal(ValType.I32); + break; + } + case ELEM_DROP: + { + var index = (int) op.operand(0); + getElement(index); + break; + } + case V128_LOAD: + case V128_LOAD8x8_S: + case V128_LOAD8x8_U: + case V128_LOAD16x4_S: + case V128_LOAD16x4_U: + case V128_LOAD32x2_S: + case V128_LOAD32x2_U: + case V128_LOAD8_SPLAT: + case V128_LOAD16_SPLAT: + case V128_LOAD32_SPLAT: + case V128_LOAD64_SPLAT: + case V128_LOAD32_ZERO: + case V128_LOAD64_ZERO: + case I8x16_SPLAT: + case I16x8_SPLAT: + case I32x4_SPLAT: + { + popVal(ValType.I32); + pushVal(ValType.V128); + break; + } + case F32x4_SPLAT: + { + popVal(ValType.F32); + pushVal(ValType.V128); + break; + } + case I64x2_SPLAT: + { + popVal(ValType.I64); + pushVal(ValType.V128); + break; + } + case F64x2_SPLAT: + { + popVal(ValType.F64); + pushVal(ValType.V128); + break; + } + case V128_CONST: + { + pushVal(ValType.V128); + break; + } + case I8x16_REPLACE_LANE: + case I16x8_REPLACE_LANE: + case I32x4_REPLACE_LANE: + case I8x16_SHL: + case I8x16_SHR_S: + case I8x16_SHR_U: + case I16x8_SHL: + case I16x8_SHR_S: + case I16x8_SHR_U: + case I32x4_SHL: + case I32x4_SHR_S: + case I32x4_SHR_U: + case I64x2_SHL: + case I64x2_SHR_S: + case I64x2_SHR_U: + { + popVal(ValType.I32); + popVal(ValType.V128); + pushVal(ValType.V128); + break; + } + case I64x2_REPLACE_LANE: + { + popVal(ValType.I64); + popVal(ValType.V128); + pushVal(ValType.V128); + break; + } + case F32x4_REPLACE_LANE: + { + popVal(ValType.F32); + popVal(ValType.V128); + pushVal(ValType.V128); + break; + } + case F64x2_REPLACE_LANE: + { + popVal(ValType.F64); + popVal(ValType.V128); + pushVal(ValType.V128); + break; + } + case I8x16_ALL_TRUE: + case I8x16_BITMASK: + case I16x8_ALL_TRUE: + case I16x8_BITMASK: + case I32x4_ALL_TRUE: + case I32x4_BITMASK: + case I64x2_ALL_TRUE: + case I64x2_BITMASK: + case I8x16_EXTRACT_LANE_S: + case I8x16_EXTRACT_LANE_U: + case I16x8_EXTRACT_LANE_S: + case I16x8_EXTRACT_LANE_U: + case I32x4_EXTRACT_LANE: + { + popVal(ValType.V128); + pushVal(ValType.I32); + break; + } + case F32x4_EXTRACT_LANE: + { + popVal(ValType.V128); + pushVal(ValType.F32); + break; + } + case I64x2_EXTRACT_LANE: + { + popVal(ValType.V128); + pushVal(ValType.I64); + break; + } + case F64x2_EXTRACT_LANE: + { + popVal(ValType.V128); + pushVal(ValType.F64); + break; + } + case I8x16_SHUFFLE: + case I8x16_SWIZZLE: + case I8x16_EQ: + case I8x16_NE: + case I8x16_LT_S: + case I8x16_LT_U: + case I8x16_GT_S: + case I8x16_GT_U: + case I8x16_LE_S: + case I8x16_LE_U: + case I8x16_GE_S: + case I8x16_GE_U: + case I8x16_MIN_S: + case I8x16_MIN_U: + case I8x16_MAX_S: + case I8x16_MAX_U: + case I8x16_AVGR_U: + case I8x16_SUB: + case I8x16_SUB_SAT_S: + case I8x16_SUB_SAT_U: + case I8x16_ADD: + case I8x16_ADD_SAT_S: + case I8x16_ADD_SAT_U: + case I8x16_NARROW_I16x8_S: + case I8x16_NARROW_I16x8_U: + case I16x8_NE: + case I16x8_EQ: + case I16x8_ADD: + case I16x8_ADD_SAT_S: + case I16x8_ADD_SAT_U: + case I16x8_SUB: + case I16x8_SUB_SAT_S: + case I16x8_SUB_SAT_U: + case I16x8_MUL: + case I16x8_LT_S: + case I16x8_LT_U: + case I16x8_GT_S: + case I16x8_GT_U: + case I16x8_LE_S: + case I16x8_LE_U: + case I16x8_GE_S: + case I16x8_GE_U: + case I16x8_MIN_S: + case I16x8_MIN_U: + case I16x8_MAX_S: + case I16x8_MAX_U: + case I16x8_AVGR_U: + case I16x8_NARROW_I32x4_S: + case I16x8_NARROW_I32x4_U: + case I16x8_Q15MULR_SAT_S: + case I16x8_EXTMUL_LOW_I8x16_S: + case I16x8_EXTMUL_HIGH_I8x16_S: + case I16x8_EXTMUL_LOW_I8x16_U: + case I16x8_EXTMUL_HIGH_I8x16_U: + case F32x4_NE: + case F32x4_LT: + case F32x4_GT: + case F32x4_LE: + case F32x4_GE: + case F32x4_EQ: + case F32x4_MUL: + case F32x4_MIN: + case F32x4_MAX: + case F32x4_PMIN: + case F32x4_PMAX: + case F32x4_DIV: + case F32x4_ADD: + case F32x4_SUB: + case I32x4_NE: + case I32x4_EQ: + case I32x4_ADD: + case I32x4_SUB: + case I32x4_MUL: + case I32x4_MIN_S: + case I32x4_MIN_U: + case I32x4_MAX_S: + case I32x4_MAX_U: + case I32x4_LT_S: + case I32x4_LT_U: + case I32x4_LE_S: + case I32x4_LE_U: + case I32x4_GE_S: + case I32x4_GE_U: + case I32x4_GT_S: + case I32x4_GT_U: + case I32x4_DOT_I16x8_S: + case I32x4_EXTMUL_LOW_I16x8_S: + case I32x4_EXTMUL_HIGH_I16x8_S: + case I32x4_EXTMUL_LOW_I16x8_U: + case I32x4_EXTMUL_HIGH_I16x8_U: + case I64x2_NE: + case I64x2_EQ: + case I64x2_LT_S: + case I64x2_LE_S: + case I64x2_GT_S: + case I64x2_GE_S: + case I64x2_ADD: + case I64x2_SUB: + case I64x2_MUL: + case I64x2_EXTMUL_LOW_I32x4_S: + case I64x2_EXTMUL_HIGH_I32x4_S: + case I64x2_EXTMUL_LOW_I32x4_U: + case I64x2_EXTMUL_HIGH_I32x4_U: + case F64x2_NE: + case F64x2_LT: + case F64x2_GT: + case F64x2_LE: + case F64x2_GE: + case F64x2_DIV: + case F64x2_MAX: + case F64x2_MIN: + case F64x2_PMAX: + case F64x2_PMIN: + case F64x2_EQ: + case F64x2_ADD: + case F64x2_SUB: + case F64x2_MUL: + case V128_AND: + case V128_ANDNOT: + case V128_OR: + case V128_XOR: + { + popVal(ValType.V128); + popVal(ValType.V128); + pushVal(ValType.V128); + break; + } + case I8x16_NEG: + case I8x16_ABS: + case I8x16_POPCNT: + case I16x8_EXTADD_PAIRWISE_I8x16_S: + case I16x8_EXTADD_PAIRWISE_I8x16_U: + case I16x8_NEG: + case I16x8_ABS: + case I16x8_EXTEND_LOW_I8x16_S: + case I16x8_EXTEND_HIGH_I8x16_S: + case I16x8_EXTEND_LOW_I8x16_U: + case I16x8_EXTEND_HIGH_I8x16_U: + case I32x4_NEG: + case I32x4_ABS: + case I32x4_EXTEND_LOW_I16x8_S: + case I32x4_EXTEND_HIGH_I16x8_S: + case I32x4_EXTEND_LOW_I16x8_U: + case I32x4_EXTEND_HIGH_I16x8_U: + case I32x4_EXTADD_PAIRWISE_I16x8_S: + case I32x4_EXTADD_PAIRWISE_I16x8_U: + case I64x2_EXTEND_LOW_I32x4_S: + case I64x2_EXTEND_HIGH_I32x4_S: + case I64x2_EXTEND_LOW_I32x4_U: + case I64x2_EXTEND_HIGH_I32x4_U: + case F32x4_NEG: + case F32x4_ABS: + case F32x4_SQRT: + case I32x4_TRUNC_SAT_F32X4_S: + case I32x4_TRUNC_SAT_F32X4_U: + case I32x4_TRUNC_SAT_F64x2_S_ZERO: + case I32x4_TRUNC_SAT_F64x2_U_ZERO: + case F32x4_CONVERT_I32x4_S: + case F32x4_CONVERT_I32x4_U: + case F32x4_CEIL: + case F32x4_FLOOR: + case F32x4_TRUNC: + case F32x4_NEAREST: + case F64x2_ABS: + case F64x2_NEG: + case F64x2_SQRT: + case F64x2_CEIL: + case F64x2_FLOOR: + case F64x2_NEAREST: + case F64x2_TRUNC: + case F64x2_CONVERT_LOW_I32x4_S: + case F64x2_CONVERT_LOW_I32x4_U: + case F64x2_PROMOTE_LOW_F32x4: + case F32x4_DEMOTE_LOW_F64x2_ZERO: + case I64x2_NEG: + case I64x2_ABS: + case V128_NOT: + { + popVal(ValType.V128); + pushVal(ValType.V128); + break; + } + case V128_BITSELECT: + { + popVal(ValType.V128); + popVal(ValType.V128); + popVal(ValType.V128); + pushVal(ValType.V128); + break; + } + case V128_ANY_TRUE: + { + popVal(ValType.V128); + pushVal(ValType.I32); + break; + } + case V128_STORE: + case V128_STORE8_LANE: + case V128_STORE16_LANE: + case V128_STORE32_LANE: + case V128_STORE64_LANE: + { + popVal(ValType.V128); + popVal(ValType.I32); + break; + } + case V128_LOAD8_LANE: + case V128_LOAD16_LANE: + case V128_LOAD32_LANE: + case V128_LOAD64_LANE: + { + popVal(ValType.V128); + popVal(ValType.I32); + pushVal(ValType.V128); + break; + } + default: + throw new IllegalArgumentException( + "Missing type validation opcode handling for " + op.opcode()); + } + } + + if (!errors.isEmpty()) { + throw new InvalidException( + errors.stream().map(Throwable::getMessage).collect(joining(" - "))); + } + + // to satisfy the check mentioned in the NOTE + // https://webassembly.github.io/spec/core/binary/modules.html#data-count-section + if (module.codeSection().isRequiresDataCount() && module.dataCountSection().isEmpty()) { + throw new MalformedException("data count section required"); + } + } + + private void validateTailCall(List funcReturnType) { + var expected = labelTypes(ctrlFrameStack.get(0)); + + if (funcReturnType.size() != expected.size()) { + throw new InvalidException("type mismatch: return arity"); + } + + for (int i = 0; i < funcReturnType.size(); i++) { + if (!ValType.matches(funcReturnType.get(i), expected.get(i))) { + throw new InvalidException( + "type mismatch: tail call doesn't match frame type at index " + i); + } + } + } + + private void VALIDATE_CALL(int funcId, boolean isReturn) { + int typeId = getFunctionType(funcId); + var types = getType(typeId); + for (int j = types.params().size() - 1; j >= 0; j--) { + popVal(types.params().get(j)); + } + pushVals(types.returns()); + if (isReturn) { + validateTailCall(types.returns()); + } + } + + private void VALIDATE_CALL_INDIRECT(long typeId, int tableId, boolean isReturn) { + popVal(ValType.I32); + var tableType = getTableType(tableId); + if (!tableType.equals(ValType.FuncRef)) { + throw new InvalidException( + "type mismatch expected a table of FuncRefs buf found " + tableType); + } + var types = getType((int) typeId); + for (int j = types.params().size() - 1; j >= 0; j--) { + popVal(types.params().get(j)); + } + pushVals(types.returns()); + if (isReturn) { + validateTailCall(types.returns()); + } + } + + private void VALIDATE_CALL_REF(int typeId, boolean isReturn) { + var rt = popRef(); + var funcType = getType(typeId); + popVals(funcType.params()); + pushVals(funcType.returns()); + + if (isReturn) { + validateTailCall(funcType.returns()); + } + + if (rt.typeIdx() != ValType.TypeIdxCode.BOT.code()) { + int idx = rt.typeIdx(); + if (idx < 0) { + // error + throw new InvalidException( + "type mismatch: call_ref should be called on a defined" + + " reference type, got operand: " + + idx); + } + } + } + + private void VALIDATE_RETURN() { + popVals(labelTypes(ctrlFrameStack.get(0))); + unreachable(); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/WasmLimits.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/WasmLimits.java new file mode 100644 index 000000000..7612cb7a6 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/WasmLimits.java @@ -0,0 +1,32 @@ +package com.dylibso.chicory.wasm; + +// Spec: https://webassembly.github.io/spec/core/appendix/implementation.html#syntactic-limits +// From: https://github.com/WebKit/webkit/blob/main/Source/JavaScriptCore/wasm/WasmLimits.h +public final class WasmLimits { + + public static final int MAX_TYPES = 1000000; + public static final int MAX_FUNCTIONS = 1000000; + public static final int MAX_IMPORTS = 100000; + public static final int MAX_EXPORTS = 100000; + public static final int MAX_EXCEPTIONS = 100000; + public static final int MAX_GLOBALS = 1000000; + public static final int MAX_DATA_SEGMENTS = 100000; + public static final int MAX_STRUCT_FIELD_COUNT = 10000; + public static final int MAX_ARRAY_NEW_FIXED_ARGS = 10000; + public static final int MAX_RECURSION_GROUP_COUNT = 1000000; + public static final int MAX_NUMBER_OF_RECURSION_GROUPS = 1000000; + public static final int MAX_SUBTYPE_SUPERTYPE_COUNT = 1; + public static final int MAX_SUBTYPE_DEPTH = 63; + + public static final int MAX_STRING_SIZE = 100000; + public static final int MAX_MODULE_SIZE = 1024 * 1024 * 1024; + public static final int MAX_FUNCTION_SIZE = 7654321; + public static final int MAX_FUNCTION_LOCALS = 50000; + public static final int MAX_FUNCTION_PARAMS = 1000; + public static final int MAX_FUNCTION_RETURNS = 1000; + + public static final int MAX_TABLE_ENTRIES = 10000000; + public static final int MAX_TABLES = 1000000; + + private WasmLimits() {} +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/WasmModule.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/WasmModule.java new file mode 100644 index 000000000..7a5863932 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/WasmModule.java @@ -0,0 +1,344 @@ +package com.dylibso.chicory.wasm; + +import static java.util.Objects.requireNonNull; + +import com.dylibso.chicory.wasm.types.CodeSection; +import com.dylibso.chicory.wasm.types.CustomSection; +import com.dylibso.chicory.wasm.types.DataCountSection; +import com.dylibso.chicory.wasm.types.DataSection; +import com.dylibso.chicory.wasm.types.ElementSection; +import com.dylibso.chicory.wasm.types.ExportSection; +import com.dylibso.chicory.wasm.types.FunctionSection; +import com.dylibso.chicory.wasm.types.GlobalSection; +import com.dylibso.chicory.wasm.types.ImportSection; +import com.dylibso.chicory.wasm.types.MemorySection; +import com.dylibso.chicory.wasm.types.NameCustomSection; +import com.dylibso.chicory.wasm.types.StartSection; +import com.dylibso.chicory.wasm.types.TableSection; +import com.dylibso.chicory.wasm.types.TagSection; +import com.dylibso.chicory.wasm.types.TypeSection; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; + +public final class WasmModule { + private final Map customSections; + + private final TypeSection typeSection; + private final ImportSection importSection; + private final FunctionSection functionSection; + private final TableSection tableSection; + private final Optional memorySection; + private final GlobalSection globalSection; + private final ExportSection exportSection; + private final Optional startSection; + private final ElementSection elementSection; + private final CodeSection codeSection; + private final DataSection dataSection; + private final Optional dataCountSection; + private final Optional tagSection; + private final List ignoredSections; + private final String digest; + + private WasmModule( + TypeSection typeSection, + ImportSection importSection, + FunctionSection functionSection, + TableSection tableSection, + Optional memorySection, + GlobalSection globalSection, + ExportSection exportSection, + Optional startSection, + ElementSection elementSection, + CodeSection codeSection, + DataSection dataSection, + Optional dataCountSection, + Optional tagSection, + Map customSections, + List ignoredSections, + String digest) { + this.typeSection = requireNonNull(typeSection); + this.importSection = requireNonNull(importSection); + this.functionSection = requireNonNull(functionSection); + this.tableSection = requireNonNull(tableSection); + this.memorySection = memorySection; + this.globalSection = requireNonNull(globalSection); + this.exportSection = requireNonNull(exportSection); + this.startSection = startSection; + this.elementSection = requireNonNull(elementSection); + this.codeSection = requireNonNull(codeSection); + this.dataSection = requireNonNull(dataSection); + this.dataCountSection = dataCountSection; + this.tagSection = tagSection; + this.customSections = Map.copyOf(customSections); + this.ignoredSections = List.copyOf(ignoredSections); + this.digest = digest; + } + + public TypeSection typeSection() { + return typeSection; + } + + public FunctionSection functionSection() { + return functionSection; + } + + public ExportSection exportSection() { + return exportSection; + } + + public Optional startSection() { + return startSection; + } + + public ImportSection importSection() { + return importSection; + } + + public CodeSection codeSection() { + return codeSection; + } + + public DataSection dataSection() { + return dataSection; + } + + public Optional dataCountSection() { + return dataCountSection; + } + + public Optional memorySection() { + return memorySection; + } + + public GlobalSection globalSection() { + return globalSection; + } + + public TableSection tableSection() { + return tableSection; + } + + public String digest() { + return digest; + } + + public List customSections() { + return new ArrayList<>(customSections.values()); + } + + public CustomSection customSection(String name) { + return customSections.get(name); + } + + public NameCustomSection nameSection() { + return (NameCustomSection) customSections.get("name"); + } + + public ElementSection elementSection() { + return elementSection; + } + + public Optional tagSection() { + return tagSection; + } + + public List ignoredSections() { + return ignoredSections; + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private TypeSection typeSection = TypeSection.builder().build(); + private ImportSection importSection = ImportSection.builder().build(); + private FunctionSection functionSection = FunctionSection.builder().build(); + private TableSection tableSection = TableSection.builder().build(); + private Optional memorySection = Optional.empty(); + private GlobalSection globalSection = GlobalSection.builder().build(); + private ExportSection exportSection = ExportSection.builder().build(); + private Optional startSection = Optional.empty(); + private ElementSection elementSection = ElementSection.builder().build(); + private CodeSection codeSection = CodeSection.builder().build(); + private DataSection dataSection = DataSection.builder().build(); + private Optional dataCountSection = Optional.empty(); + private Optional tagSection = Optional.empty(); + private final Map customSections = new HashMap<>(); + private final List ignoredSections = new ArrayList<>(); + private boolean validate = true; + private String digest; + + private Builder() {} + + public Builder setTypeSection(TypeSection ts) { + this.typeSection = requireNonNull(ts); + return this; + } + + public Builder setImportSection(ImportSection is) { + this.importSection = requireNonNull(is); + return this; + } + + public Builder setFunctionSection(FunctionSection fs) { + this.functionSection = requireNonNull(fs); + return this; + } + + public Builder setTableSection(TableSection ts) { + this.tableSection = requireNonNull(ts); + return this; + } + + public Builder setMemorySection(MemorySection ms) { + this.memorySection = Optional.ofNullable(ms); + return this; + } + + public Builder setGlobalSection(GlobalSection gs) { + this.globalSection = requireNonNull(gs); + return this; + } + + public Builder setExportSection(ExportSection es) { + this.exportSection = requireNonNull(es); + return this; + } + + public Builder setStartSection(StartSection ss) { + this.startSection = Optional.ofNullable(ss); + return this; + } + + public Builder setElementSection(ElementSection es) { + this.elementSection = requireNonNull(es); + return this; + } + + public Builder setCodeSection(CodeSection cs) { + this.codeSection = requireNonNull(cs); + return this; + } + + public Builder setDataSection(DataSection ds) { + this.dataSection = requireNonNull(ds); + return this; + } + + public Builder setDataCountSection(DataCountSection dcs) { + this.dataCountSection = Optional.ofNullable(dcs); + return this; + } + + public Builder setTagSection(TagSection ts) { + this.tagSection = Optional.ofNullable(ts); + return this; + } + + public Builder addCustomSection(String name, CustomSection cs) { + requireNonNull(name); + requireNonNull(cs); + this.customSections.put(name, cs); + return this; + } + + public Builder addIgnoredSection(int id) { + this.ignoredSections.add(id); + return this; + } + + public Builder withValidation(boolean validate) { + this.validate = validate; + return this; + } + + public Builder withDigest(String digest) { + this.digest = digest; + return this; + } + + public WasmModule build() { + var module = + new WasmModule( + typeSection, + importSection, + functionSection, + tableSection, + memorySection, + globalSection, + exportSection, + startSection, + elementSection, + codeSection, + dataSection, + dataCountSection, + tagSection, + customSections, + ignoredSections, + digest); + + var validator = new Validator(module); + validator.validateModule(); + if (validate) { + validator.validateTypes(); + validator.validateFunctions(); + validator.validateGlobals(); + validator.validateElements(); + validator.validateData(); + validator.validateTags(); + validator.validateTables(); + } + + return module; + } + } + + // Comparison uses everything but the custom section + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof WasmModule)) { + return false; + } + WasmModule that = (WasmModule) o; + return Objects.equals(typeSection, that.typeSection) + && Objects.equals(importSection, that.importSection) + && Objects.equals(functionSection, that.functionSection) + && Objects.equals(tableSection, that.tableSection) + && Objects.equals(memorySection, that.memorySection) + && Objects.equals(globalSection, that.globalSection) + && Objects.equals(exportSection, that.exportSection) + && Objects.equals(startSection, that.startSection) + && Objects.equals(elementSection, that.elementSection) + && Objects.equals(codeSection, that.codeSection) + && Objects.equals(dataSection, that.dataSection) + && Objects.equals(dataCountSection, that.dataCountSection) + && Objects.equals(tagSection, that.tagSection) + && Objects.equals(ignoredSections, that.ignoredSections); + } + + @Override + public int hashCode() { + return Objects.hash( + typeSection, + importSection, + functionSection, + tableSection, + memorySection, + globalSection, + exportSection, + startSection, + elementSection, + codeSection, + dataSection, + dataCountSection, + tagSection); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/WasmWriter.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/WasmWriter.java new file mode 100644 index 000000000..f2de85384 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/WasmWriter.java @@ -0,0 +1,44 @@ +package com.dylibso.chicory.wasm; + +import static com.dylibso.chicory.wasm.Parser.MAGIC_BYTES; +import static com.dylibso.chicory.wasm.Parser.VERSION_BYTES; +import static java.lang.Integer.toUnsignedLong; + +import com.dylibso.chicory.wasm.types.RawSection; +import java.io.ByteArrayOutputStream; + +public final class WasmWriter { + + private final ByteArrayOutputStream out = new ByteArrayOutputStream(); + + public WasmWriter() { + out.writeBytes(MAGIC_BYTES); + out.writeBytes(VERSION_BYTES); + } + + public void writeSection(RawSection section) { + writeSection(section.sectionId(), section.contents()); + } + + public void writeSection(int sectionId, byte[] contents) { + out.write(sectionId); + writeVarUInt32(out, contents.length); + out.writeBytes(contents); + } + + public byte[] bytes() { + return out.toByteArray(); + } + + public static void writeVarUInt32(ByteArrayOutputStream out, int value) { + long x = toUnsignedLong(value); + while (true) { + if (x < 0x80) { + out.write((int) x); + break; + } + out.write((int) ((x & 0x7F) | 0x80)); + x >>= 7; + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/io/InputStreams.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/io/InputStreams.java new file mode 100644 index 000000000..91f8a79bb --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/io/InputStreams.java @@ -0,0 +1,28 @@ +package com.dylibso.chicory.wasm.io; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; + +public final class InputStreams { + private InputStreams() {} + + public static byte[] readAllBytes(InputStream is) throws IOException { + if (is == null) { + throw new IllegalArgumentException("InputStream cannot be null"); + } + + int bufLen = 1024; + byte[] buf = new byte[bufLen]; + + // Create an output stream to store all bytes + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + + int bytesRead; + while ((bytesRead = is.read(buf, 0, bufLen)) != -1) { + outputStream.write(buf, 0, bytesRead); + } + + return outputStream.toByteArray(); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ActiveDataSegment.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ActiveDataSegment.java new file mode 100644 index 000000000..24eb1c468 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ActiveDataSegment.java @@ -0,0 +1,43 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.List; +import java.util.Objects; + +public final class ActiveDataSegment extends DataSegment { + private final long idx; + private final List offsetInstructions; + + public ActiveDataSegment(long idx, List offsetInstructions, byte[] data) { + super(data); + this.idx = idx; + this.offsetInstructions = List.copyOf(offsetInstructions); + } + + public long index() { + return idx; + } + + public List offsetInstructions() { + return offsetInstructions; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof ActiveDataSegment)) { + return false; + } + if (!super.equals(o)) { + return false; + } + ActiveDataSegment that = (ActiveDataSegment) o; + return idx == that.idx && Objects.equals(offsetInstructions, that.offsetInstructions); + } + + @Override + public int hashCode() { + return Objects.hash(super.hashCode(), idx, offsetInstructions); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ActiveElement.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ActiveElement.java new file mode 100644 index 000000000..80502d349 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ActiveElement.java @@ -0,0 +1,44 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.List; + +/** + * An active element. + * An active element copies its elements into a table during initialization of that table. + */ +public final class ActiveElement extends Element { + private final int tableIndex; + private final List offset; + + /** + * Construct a new instance. + * + * @param type the type of the element values (must not be {@code null}) + * @param initializers the list of instruction lists which are used to initialize each element in the range (must not be {@code null}) + * @param tableIndex the index of the table which is to be initialized + * @param offset the list of instructions which give the offset into the table (must not be {@code null}) + */ + public ActiveElement( + ValType type, + List> initializers, + int tableIndex, + List offset) { + super(type, initializers); + this.tableIndex = tableIndex; + this.offset = List.copyOf(offset); + } + + /** + * @return the table to actively initialize + */ + public int tableIndex() { + return tableIndex; + } + + /** + * @return a constant expression defining the offset into the table + */ + public List offset() { + return offset; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/AnnotatedInstruction.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/AnnotatedInstruction.java new file mode 100644 index 000000000..805c16d68 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/AnnotatedInstruction.java @@ -0,0 +1,238 @@ +package com.dylibso.chicory.wasm.types; + +import com.dylibso.chicory.wasm.InvalidException; +import java.util.List; +import java.util.Objects; +import java.util.Optional; + +/* + * An instruction with additional metadata for control flow. + */ +public final class AnnotatedInstruction extends Instruction { + public static final int UNDEFINED_LABEL = -1; + + // metadata fields + private final int depth; + private final int labelTrue; + private final int labelFalse; + private final List labelTable; + private final List catches; + private final Instruction scope; + + private AnnotatedInstruction( + int address, + OpCode opcode, + long[] operands, + int depth, + int labelTrue, + int labelFalse, + List labelTable, + List catches, + Instruction scope) { + super(address, opcode, operands); + this.depth = depth; + this.labelTrue = labelTrue; + this.labelFalse = labelFalse; + this.labelTable = labelTable; + this.catches = catches; + this.scope = scope; + } + + public int labelTrue() { + return labelTrue; + } + + public int labelFalse() { + return labelFalse; + } + + public List labelTable() { + return labelTable; + } + + public List catches() { + return catches; + } + + public int depth() { + return depth; + } + + public Instruction scope() { + return scope; + } + + @Override + public String toString() { + return "AnnotatedInstruction{" + + "instruction=" + + super.toString() + + ", depth=" + + depth + + ", labelTrue=" + + labelTrue + + ", labelFalse=" + + labelFalse + + ", labelTable=" + + labelTable + + ", catches=" + + catches + + ", scope=" + + scope + + '}'; + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private Instruction base; + private int depth; + private Optional labelTrue = Optional.empty(); + private Optional labelFalse = Optional.empty(); + private Optional> labelTable = Optional.empty(); + private Optional> catches = Optional.empty(); + private Optional scope = Optional.empty(); + + private Builder() {} + + public OpCode opcode() { + return base.opcode(); + } + + public Optional scope() { + return scope; + } + + public Builder from(Instruction ins) { + this.base = ins; + return this; + } + + public Builder withDepth(int depth) { + this.depth = depth; + return this; + } + + public Builder withLabelTrue(int label) { + this.labelTrue = Optional.of(label); + return this; + } + + public Builder withLabelFalse(int label) { + this.labelFalse = Optional.of(label); + return this; + } + + public Builder updateLabelFalse(int label) { + if (this.labelFalse.equals(this.labelTrue)) { + this.labelFalse = Optional.of(label); + } + return this; + } + + public Builder withLabelTable(List labelTable) { + this.labelTable = Optional.of(labelTable); + return this; + } + + public Builder withCatches(List catches) { + this.catches = Optional.of(catches); + return this; + } + + public Builder withScope(Instruction scope) { + this.scope = Optional.of(scope); + return this; + } + + public AnnotatedInstruction build() { + switch (base.opcode()) { + case BLOCK: + case LOOP: + case END: + case IF: + case TRY_TABLE: + assert (scope.isPresent()); + break; + default: + assert (scope.isEmpty()); + break; + } + switch (base.opcode()) { + case BR_IF: + case BR_ON_NULL: + case BR_ON_NON_NULL: + case IF: + if (labelFalse.isEmpty()) { + throw new InvalidException("unknown label " + base); + } + // fallthrough + case ELSE: + case BR: + if (labelTrue.isEmpty()) { + throw new InvalidException("unknown label " + base); + } + break; + default: + assert (labelTrue.isEmpty()); + assert (labelFalse.isEmpty()); + break; + } + switch (base.opcode()) { + case BR_TABLE: + if (labelTable.isEmpty()) { + throw new InvalidException("unknown label table " + base); + } + break; + default: + assert (labelTable.isEmpty()); + break; + } + switch (base.opcode()) { + case TRY_TABLE: + if (catches.isEmpty()) { + throw new InvalidException("unknown catches " + base); + } + break; + default: + assert (catches.isEmpty()); + break; + } + + return new AnnotatedInstruction( + base.address(), + base.opcode(), + base.operands(), + depth, + labelTrue.orElse(UNDEFINED_LABEL), + labelFalse.orElse(UNDEFINED_LABEL), + labelTable.orElse(List.of()), + catches.orElse(null), + scope.orElse(null)); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof AnnotatedInstruction)) { + return false; + } + AnnotatedInstruction that = (AnnotatedInstruction) o; + return depth == that.depth + && labelTrue == that.labelTrue + && labelFalse == that.labelFalse + && Objects.equals(labelTable, that.labelTable) + && Objects.equals(catches, that.catches) + && Objects.equals(scope, that.scope); + } + + @Override + public int hashCode() { + return Objects.hash(depth, labelTrue, labelFalse, labelTable, catches, scope); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/CatchOpCode.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/CatchOpCode.java new file mode 100644 index 000000000..6a0da1296 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/CatchOpCode.java @@ -0,0 +1,108 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +public enum CatchOpCode { + CATCH(0x00), + CATCH_REF(0x01), + CATCH_ALL(0x02), + CATCH_ALL_REF(0x03); + + private static final int OP_CODES_SIZE = 4; + + // trick: the enum constructor cannot access its own static fields + // but can access another class + private static final class CatchOpCodes { + private CatchOpCodes() {} + + private static final CatchOpCode[] byOpCode = new CatchOpCode[OP_CODES_SIZE]; + } + + private final int opcode; + + CatchOpCode(int opcode) { + this.opcode = opcode; + CatchOpCodes.byOpCode[opcode] = this; + } + + public int opcode() { + return opcode; + } + + public static CatchOpCode byOpCode(int opcode) { + return CatchOpCodes.byOpCode[opcode]; + } + + public static final class Catch { + private final CatchOpCode opcode; + private final int tag; + private final int label; + private int resolvedLabel; + + private Catch(CatchOpCode opcode, int label) { + this(opcode, -1, label); + assert (opcode == CATCH_ALL || opcode == CATCH_ALL_REF); + } + + private Catch(CatchOpCode opcode, int tag, int label) { + assert (tag == -1 || opcode == CATCH || opcode == CATCH_REF); + this.opcode = opcode; + this.tag = tag; + this.label = label; + } + + public CatchOpCode opcode() { + return opcode; + } + + public int tag() { + return tag; + } + + public int label() { + return label; + } + + public void resolvedLabel(int label) { + resolvedLabel = label; + } + + public int resolvedLabel() { + return resolvedLabel; + } + } + + @SuppressWarnings("ModifiedControlVariable") + public static List decode(long[] operands) { + var length = operands[1]; + var result = new ArrayList(); + for (int i = 2; i < operands.length; i++) { + var catchEnum = CatchOpCode.byOpCode((int) operands[i++]); + switch (catchEnum) { + case CATCH: + case CATCH_REF: + { + var tag = (int) operands[i++]; + var label = (int) operands[i]; + result.add(new Catch(catchEnum, tag, label)); + break; + } + case CATCH_ALL: + case CATCH_ALL_REF: + { + var label = (int) operands[i]; + result.add(new Catch(catchEnum, label)); + break; + } + } + } + assert (result.size() == length); + return result; + } + + public static List allLabels(long[] operands) { + return decode(operands).stream().map(Catch::label).collect(Collectors.toList()); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/CodeSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/CodeSection.java new file mode 100644 index 000000000..5535c3552 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/CodeSection.java @@ -0,0 +1,82 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public final class CodeSection extends Section { + private final List functionBodies; + private final boolean requiresDataCount; + + private CodeSection(List functionBodies, boolean requiresDataCount) { + super(SectionId.CODE); + this.functionBodies = List.copyOf(functionBodies); + this.requiresDataCount = requiresDataCount; + } + + public FunctionBody[] functionBodies() { + return functionBodies.toArray(new FunctionBody[0]); + } + + public int functionBodyCount() { + return functionBodies.size(); + } + + public FunctionBody getFunctionBody(int idx) { + return functionBodies.get(idx); + } + + public boolean isRequiresDataCount() { + return requiresDataCount; + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List functionBodies = new ArrayList<>(); + private boolean requiresDataCount; + + private Builder() {} + + /** + * Add a function body to this section. + * + * @param functionBody the function body to add to this section (must not be {@code null}) + * @return the Builder + */ + public Builder addFunctionBody(FunctionBody functionBody) { + Objects.requireNonNull(functionBody, "functionBody"); + functionBodies.add(functionBody); + return this; + } + + public Builder setRequiresDataCount(boolean requiresDataCount) { + this.requiresDataCount = requiresDataCount; + return this; + } + + public CodeSection build() { + return new CodeSection(functionBodies, requiresDataCount); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof CodeSection)) { + return false; + } + CodeSection that = (CodeSection) o; + return requiresDataCount == that.requiresDataCount + && Objects.equals(functionBodies, that.functionBodies); + } + + @Override + public int hashCode() { + return Objects.hash(functionBodies, requiresDataCount); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/CustomSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/CustomSection.java new file mode 100644 index 000000000..35c05a389 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/CustomSection.java @@ -0,0 +1,13 @@ +package com.dylibso.chicory.wasm.types; + +/** + * A custom section of some kind. + */ +public abstract class CustomSection extends Section { + + CustomSection() { + super(SectionId.CUSTOM); + } + + public abstract String name(); +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DataCountSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DataCountSection.java new file mode 100644 index 000000000..f975ee8b2 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DataCountSection.java @@ -0,0 +1,48 @@ +package com.dylibso.chicory.wasm.types; + +public final class DataCountSection extends Section { + private final int dataCount; + + private DataCountSection(int dataCount) { + super(SectionId.DATA_COUNT); + this.dataCount = dataCount; + } + + public int dataCount() { + return dataCount; + } + + public static Builder builder() { + return new Builder(); + } + + public static class Builder { + private int dataCount; + + public Builder withDataCount(int dataCount) { + this.dataCount = dataCount; + return this; + } + + public DataCountSection build() { + return new DataCountSection(dataCount); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof DataCountSection)) { + return false; + } + DataCountSection that = (DataCountSection) o; + return dataCount == that.dataCount; + } + + @Override + public int hashCode() { + return Integer.hashCode(dataCount); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DataSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DataSection.java new file mode 100644 index 000000000..fb75b3627 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DataSection.java @@ -0,0 +1,69 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public final class DataSection extends Section { + private final List dataSegments; + + private DataSection(List dataSegments) { + super(SectionId.DATA); + this.dataSegments = List.copyOf(dataSegments); + } + + public DataSegment[] dataSegments() { + return dataSegments.toArray(new DataSegment[0]); + } + + public int dataSegmentCount() { + return dataSegments.size(); + } + + public DataSegment getDataSegment(int idx) { + return dataSegments.get(idx); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List dataSegments = new ArrayList<>(); + + private Builder() {} + + /** + * Add a data segment definition to this section. + * + * @param dataSegment the data segment to add to this section (must not be {@code null}) + * @return the Builder + */ + public Builder addDataSegment(DataSegment dataSegment) { + Objects.requireNonNull(dataSegment, "dataSegment"); + dataSegments.add(dataSegment); + return this; + } + + public DataSection build() { + return new DataSection(dataSegments); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof DataSection)) { + return false; + } + DataSection that = (DataSection) o; + return Objects.equals(dataSegments, that.dataSegments); + } + + @Override + public int hashCode() { + return Objects.hashCode(dataSegments); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DataSegment.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DataSegment.java new file mode 100644 index 000000000..afd8e3a9b --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DataSegment.java @@ -0,0 +1,33 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.Arrays; +import java.util.Objects; + +public abstract class DataSegment { + private final byte[] data; + + DataSegment(byte[] data) { + this.data = data.clone(); + } + + public byte[] data() { + return data.clone(); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof DataSegment)) { + return false; + } + DataSegment that = (DataSegment) o; + return Objects.deepEquals(data, that.data); + } + + @Override + public int hashCode() { + return Arrays.hashCode(data); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DeclarativeElement.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DeclarativeElement.java new file mode 100644 index 000000000..1210711ff --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/DeclarativeElement.java @@ -0,0 +1,20 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.List; + +/** + * A declarative element. + * A declarative element is not available at runtime. + */ +public final class DeclarativeElement extends Element { + + /** + * Construct a new instance. + * + * @param type the type of the element values (must not be {@code null}) + * @param initializers the list of instruction lists which are used to initialize each element in the range (must not be {@code null}) + */ + public DeclarativeElement(ValType type, List> initializers) { + super(type, initializers); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Element.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Element.java new file mode 100644 index 000000000..1c8f058db --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Element.java @@ -0,0 +1,65 @@ +package com.dylibso.chicory.wasm.types; + +import static java.util.Objects.requireNonNull; + +import java.util.List; +import java.util.Objects; + +/** + * An element, used to initialize table ranges. + */ +public abstract class Element { + private final ValType type; + private final List> initializers; + + /** + * Construct a new instance. + * + * @param type the type of the element values (must not be {@code null}) + * @param initializers the list of instruction lists which are used to initialize each element in the range (must not be {@code null}) + */ + Element(ValType type, List> initializers) { + this.type = requireNonNull(type, "type"); + this.initializers = List.copyOf(initializers); + } + + /** + * @return the type of the element values + */ + public ValType type() { + return type; + } + + /** + * @return the list of instruction lists which are used to initialize each element in the range + */ + public List> initializers() { + return initializers; + } + + /** + * This value is equal to the number of initializers present. + * + * @return the number of elements defined by this section + */ + public int elementCount() { + return initializers().size(); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof Element)) { + return false; + } + Element element = (Element) o; + return type.equals(element.type) && Objects.equals(initializers, element.initializers); + } + + @Override + public int hashCode() { + return Objects.hash(type, initializers); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ElementSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ElementSection.java new file mode 100644 index 000000000..6dc9606a9 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ElementSection.java @@ -0,0 +1,72 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.stream.Stream; + +public final class ElementSection extends Section { + private final List elements; + + private ElementSection(List elements) { + super(SectionId.ELEMENT); + this.elements = List.copyOf(elements); + } + + public Element[] elements() { + return elements.toArray(new Element[0]); + } + + public int elementCount() { + return elements.size(); + } + + public Element getElement(int idx) { + return elements.get(idx); + } + + public Stream stream() { + return elements.stream(); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List elements = new ArrayList<>(); + + /** + * Add an element definition to this section. + * + * @param element the element to add to this section (must not be {@code null}) + * @return the Builder + */ + public Builder addElement(Element element) { + Objects.requireNonNull(element, "element"); + elements.add(element); + return this; + } + + public ElementSection build() { + return new ElementSection(elements); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof ElementSection)) { + return false; + } + ElementSection that = (ElementSection) o; + return Objects.equals(elements, that.elements); + } + + @Override + public int hashCode() { + return Objects.hashCode(elements); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Export.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Export.java new file mode 100644 index 000000000..b625170c0 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Export.java @@ -0,0 +1,68 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.Objects; + +/** + * An exported definition. + *

+ * See Exports for + * reference. + */ +public class Export { + private final String name; + private final int index; + private final ExternalType exportType; + + /** + * Construct a new instance. + * The index is interpreted according to {@code type}. + * + * @param name the export name (must not be {@code null}) + * @param index the index of the definition to export + * @param exportType the export type (must not be {@code null}) + */ + public Export(String name, int index, ExternalType exportType) { + this.name = Objects.requireNonNull(name, "name"); + this.index = index; + this.exportType = Objects.requireNonNull(exportType, "type"); + } + + /** + * @return the export name + */ + public String name() { + return name; + } + + /** + * @return the export index + */ + public int index() { + return index; + } + + /** + * @return the type of exported definition + */ + public ExternalType exportType() { + return exportType; + } + + @Override + public int hashCode() { + return (name.hashCode() * 31 + index) * 31 + exportType.hashCode(); + } + + @Override + public boolean equals(Object obj) { + return obj instanceof Export && equals((Export) obj); + } + + public boolean equals(Export other) { + return this == other + || other != null + && index == other.index + && exportType == other.exportType + && name.equals(other.name); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ExportSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ExportSection.java new file mode 100644 index 000000000..aa9dbaba5 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ExportSection.java @@ -0,0 +1,65 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public final class ExportSection extends Section { + private final List exports; + + private ExportSection(List exports) { + super(SectionId.EXPORT); + this.exports = List.copyOf(exports); + } + + public int exportCount() { + return exports.size(); + } + + public Export getExport(int idx) { + return exports.get(idx); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List exports = new ArrayList<>(); + + private Builder() {} + + /** + * Add an export definition to this section. + * + * @param export the export to add to this section (must not be {@code null}) + * @return the Builder + */ + public Builder addExport(Export export) { + Objects.requireNonNull(export, "export"); + exports.add(export); + return this; + } + + public ExportSection build() { + return new ExportSection(exports); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof ExportSection)) { + return false; + } + ExportSection that = (ExportSection) o; + return Objects.equals(exports, that.exports); + } + + @Override + public int hashCode() { + return Objects.hashCode(exports); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ExternalType.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ExternalType.java new file mode 100644 index 000000000..4fa046b15 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ExternalType.java @@ -0,0 +1,41 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.List; + +/** + * The type of external definition, import, or export. + *

+ * See External Types for + * reference. + * See also Exceptions + * for the history of {@link #TAG}. + */ +public enum ExternalType { + // note: keep in order + FUNCTION(0x00), + TABLE(0x01), + MEMORY(0x02), + GLOBAL(0x03), + TAG(0x04); + + private final int id; + + @SuppressWarnings("EnumOrdinal") + ExternalType(int id) { + this.id = id; + assert ordinal() == id; + } + + /** + * @return the numerical identifier for this external kind + */ + public int id() { + return id; + } + + private static final List values = List.of(values()); + + public static ExternalType byId(int id) { + return values.get(id); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionBody.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionBody.java new file mode 100644 index 000000000..a40b4cf17 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionBody.java @@ -0,0 +1,40 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.List; +import java.util.Objects; + +public final class FunctionBody { + private final List locals; + private final List instructions; + + public FunctionBody(List locals, List instructions) { + this.locals = List.copyOf(locals); + this.instructions = List.copyOf(instructions); + } + + public List localTypes() { + return locals; + } + + public List instructions() { + return instructions; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof FunctionBody)) { + return false; + } + FunctionBody that = (FunctionBody) o; + return Objects.equals(locals, that.locals) + && Objects.equals(instructions, that.instructions); + } + + @Override + public int hashCode() { + return Objects.hash(locals, instructions); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionImport.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionImport.java new file mode 100644 index 000000000..e7192f480 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionImport.java @@ -0,0 +1,52 @@ +package com.dylibso.chicory.wasm.types; + +/** + * An imported function. + */ +public final class FunctionImport extends Import { + private final int typeIndex; + + /** + * Construct a new instance. + * + * @param moduleName the module name (must not be {@code null}) + * @param name the imported function name (must not be {@code null}) + * @param typeIndex the type index of the function (should correspond to a valid index in the type section) + */ + public FunctionImport(String moduleName, String name, int typeIndex) { + super(moduleName, name); + this.typeIndex = typeIndex; + } + + /** + * @return the type index corresponding to the imported function's type + */ + public int typeIndex() { + return typeIndex; + } + + @Override + public ExternalType importType() { + return ExternalType.FUNCTION; + } + + @Override + public boolean equals(Import other) { + return other instanceof FunctionImport && equals((FunctionImport) other); + } + + public boolean equals(FunctionImport other) { + return this == other || super.equals(other) && typeIndex == other.typeIndex; + } + + @Override + public int hashCode() { + return super.hashCode() * 19 + typeIndex; + } + + @Override + public StringBuilder toString(StringBuilder b) { + b.append("func (type=").append(typeIndex).append(')'); + return super.toString(b); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionSection.java new file mode 100644 index 000000000..8544b57b0 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionSection.java @@ -0,0 +1,68 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public final class FunctionSection extends Section { + private final List typeIndices; + + private FunctionSection(List typeIndices) { + super(SectionId.FUNCTION); + this.typeIndices = List.copyOf(typeIndices); + } + + public int getFunctionType(int idx) { + return typeIndices.get(idx); + } + + public FunctionType getFunctionType(int idx, TypeSection typeSection) { + return typeSection.getType(getFunctionType(idx)); + } + + public int functionCount() { + return typeIndices.size(); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List typeIndices = new ArrayList<>(); + + private Builder() {} + + /** + * Add a function type index to this section. + * + * @param typeIndex the type index to add (should be a valid index into the type section) + * @return the Builder + */ + public Builder addFunctionType(int typeIndex) { + typeIndices.add(typeIndex); + return this; + } + + public FunctionSection build() { + return new FunctionSection(typeIndices); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof FunctionSection)) { + return false; + } + FunctionSection that = (FunctionSection) o; + return Objects.equals(typeIndices, that.typeIndices); + } + + @Override + public int hashCode() { + return Objects.hashCode(typeIndices); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionType.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionType.java new file mode 100644 index 000000000..5014013c8 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/FunctionType.java @@ -0,0 +1,112 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.List; +import java.util.Objects; + +public final class FunctionType { + private final List params; + private final List returns; + private final int hashCode; + + private FunctionType(List params, List returns) { + this.params = params; + this.returns = returns; + hashCode = Objects.hash(params, returns); + } + + public List params() { + return params; + } + + public List returns() { + return returns; + } + + public boolean paramsMatch(FunctionType other) { + return params.equals(other.params); + } + + public boolean returnsMatch(FunctionType other) { + return returns.equals(other.returns); + } + + @Override + public boolean equals(Object obj) { + return obj instanceof FunctionType && equals((FunctionType) obj); + } + + public boolean equals(FunctionType other) { + return hashCode == other.hashCode && paramsMatch(other) && returnsMatch(other); + } + + @Override + public int hashCode() { + return hashCode; + } + + private static final FunctionType empty = new FunctionType(List.of(), List.of()); + + public static FunctionType returning(ValType valType) { + return new FunctionType(List.of(), List.of(valType)); + } + + public static FunctionType accepting(ValType valType) { + return new FunctionType(List.of(valType), List.of()); + } + + public boolean typesMatch(FunctionType other) { + return paramsMatch(other) && returnsMatch(other); + } + + public static FunctionType of(List params, List returns) { + if (params.isEmpty()) { + if (returns.isEmpty()) { + return empty; + } + if (returns.size() == 1) { + return returning(returns.get(0)); + } + } else if (returns.isEmpty()) { + if (params.size() == 1) { + return accepting(params.get(0)); + } + } + return new FunctionType(List.copyOf(params), List.copyOf(returns)); + } + + public static FunctionType of(ValType[] params, ValType[] returns) { + return of(List.of(params), List.of(returns)); + } + + public static FunctionType empty() { + return empty; + } + + @Override + public String toString() { + var builder = new StringBuilder(); + builder.append('('); + var nParams = this.params.size(); + for (var i = 0; i < nParams; i++) { + builder.append(this.params.get(i).toString()); + if (i < nParams - 1) { + builder.append(','); + } + } + builder.append(") -> "); + var nReturns = this.returns.size(); + if (nReturns == 0) { + builder.append("nil"); + } else { + builder.append('('); + for (var i = 0; i < nReturns; i++) { + builder.append(this.returns.get(i).toString()); + if (i < nReturns - 1) { + builder.append(','); + } + } + builder.append(')'); + } + return builder.toString(); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Global.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Global.java new file mode 100644 index 000000000..480b7abb0 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Global.java @@ -0,0 +1,60 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.List; +import java.util.Objects; + +/** + * The definition of a global variable in the model of a module. + */ +public final class Global { + private final ValType valType; + private final MutabilityType mutabilityType; + private final List init; + + public Global(ValType valType, MutabilityType mutabilityType, List init) { + this.valType = valType; + this.mutabilityType = mutabilityType; + this.init = List.copyOf(init); + } + + /** + * @deprecated use {@link #Global(ValType, MutabilityType, List)} + */ + @Deprecated(since = "1.3.0") + public Global(ValueType valueType, MutabilityType mutabilityType, List init) { + this.valType = valueType.toValType(); + this.mutabilityType = mutabilityType; + this.init = List.copyOf(init); + } + + public MutabilityType mutabilityType() { + return mutabilityType; + } + + public ValType valueType() { + return valType; + } + + public List initInstructions() { + return init; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof Global)) { + return false; + } + Global global = (Global) o; + return valType.equals(global.valType) + && mutabilityType == global.mutabilityType + && Objects.equals(init, global.init); + } + + @Override + public int hashCode() { + return Objects.hash(valType, mutabilityType, init); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/GlobalImport.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/GlobalImport.java new file mode 100644 index 000000000..71a478511 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/GlobalImport.java @@ -0,0 +1,79 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.Objects; + +/** + * An imported global variable or constant. + */ +public final class GlobalImport extends Import { + private final MutabilityType mutabilityType; + private final ValType type; + + /** + * Construct a new instance. + * + * @param moduleName the module name (must not be {@code null}) + * @param name the imported global name (must not be {@code null}) + * @param mutabilityType the mutability type of the global (must not be {@code null}) + * @param type the type of the value stored in the global (must not be {@code null}) + */ + public GlobalImport( + String moduleName, String name, MutabilityType mutabilityType, ValType type) { + super(moduleName, name); + this.mutabilityType = Objects.requireNonNull(mutabilityType, "mutabilityType"); + this.type = Objects.requireNonNull(type, "type"); + } + + /** + * @deprecated use {@link #GlobalImport(String, String, MutabilityType, ValType)} + */ + @Deprecated(since = "1.3.0") + public GlobalImport( + String moduleName, String name, MutabilityType mutabilityType, ValueType type) { + super(moduleName, name); + this.mutabilityType = Objects.requireNonNull(mutabilityType, "mutabilityType"); + this.type = Objects.requireNonNull(type, "type").toValType(); + } + + /** + * @return the mutability type of the global + */ + public MutabilityType mutabilityType() { + return mutabilityType; + } + + /** + * @return the type of the value stored in the global + */ + public ValType type() { + return type; + } + + @Override + public ExternalType importType() { + return ExternalType.GLOBAL; + } + + @Override + public boolean equals(Import other) { + return other instanceof GlobalImport && equals((GlobalImport) other); + } + + public boolean equals(GlobalImport other) { + return this == other + || super.equals(other) + && mutabilityType == other.mutabilityType + && type == other.type; + } + + @Override + public int hashCode() { + return (super.hashCode() * 19 + mutabilityType.hashCode()) * 19 + type.hashCode(); + } + + @Override + public StringBuilder toString(StringBuilder b) { + b.append("global (type=").append(type).append(",mut=").append(mutabilityType).append(')'); + return super.toString(b); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/GlobalSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/GlobalSection.java new file mode 100644 index 000000000..f36a1a983 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/GlobalSection.java @@ -0,0 +1,69 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public final class GlobalSection extends Section { + private final List globals; + + private GlobalSection(List globals) { + super(SectionId.GLOBAL); + this.globals = List.copyOf(globals); + } + + public Global[] globals() { + return globals.toArray(new Global[0]); + } + + public int globalCount() { + return globals.size(); + } + + public Global getGlobal(int idx) { + return globals.get(idx); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List globals = new ArrayList<>(); + + private Builder() {} + + /** + * Add a global variable definition to this section. + * + * @param global the global to add to this section (must not be {@code null}) + * @return the Builder + */ + public Builder addGlobal(Global global) { + Objects.requireNonNull(global, "global"); + globals.add(global); + return this; + } + + public GlobalSection build() { + return new GlobalSection(globals); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof GlobalSection)) { + return false; + } + GlobalSection that = (GlobalSection) o; + return Objects.equals(globals, that.globals); + } + + @Override + public int hashCode() { + return Objects.hashCode(globals); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Import.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Import.java new file mode 100644 index 000000000..aea3d8981 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Import.java @@ -0,0 +1,63 @@ +package com.dylibso.chicory.wasm.types; + +import static java.util.Objects.requireNonNull; + +import java.util.Objects; + +/** + * Some imported entity. + *

+ * See Imports for + * reference. + */ +public abstract class Import { + private final String module; + private final String name; + + Import(String module, String name) { + this.module = requireNonNull(module, "moduleName"); + this.name = requireNonNull(name, "name"); + } + + /** + * @return the module name to import from + */ + public String module() { + return module; + } + + /** + * @return the import name + */ + public String name() { + return name; + } + + /** + * @return the kind of imported definition + */ + public abstract ExternalType importType(); + + @Override + public boolean equals(Object obj) { + return obj instanceof Import && equals((Import) obj); + } + + public boolean equals(Import other) { + return other != null && module.equals(other.module) && name.equals(other.name); + } + + @Override + public int hashCode() { + return Objects.hash(module, name); + } + + public StringBuilder toString(StringBuilder b) { + return b.append('<').append(module).append('.').append(name).append('>'); + } + + @Override + public String toString() { + return toString(new StringBuilder()).toString(); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ImportSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ImportSection.java new file mode 100644 index 000000000..ae1ae0281 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ImportSection.java @@ -0,0 +1,74 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.stream.Stream; + +public final class ImportSection extends Section { + private final List imports; + + private ImportSection(List imports) { + super(SectionId.IMPORT); + this.imports = List.copyOf(imports); + } + + public int importCount() { + return imports.size(); + } + + public Import getImport(int idx) { + return imports.get(idx); + } + + public Stream stream() { + return imports.stream(); + } + + public int count(ExternalType type) { + return (int) imports.stream().filter(i -> i.importType() == type).count(); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List imports = new ArrayList<>(); + + private Builder() {} + + /** + * Add an import definition to this section. + * + * @param import_ the import to add to this section (must not be {@code null}) + * @return the Builder + */ + public Builder addImport(Import import_) { + Objects.requireNonNull(import_, "import_"); + imports.add(import_); + return this; + } + + public ImportSection build() { + return new ImportSection(imports); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof ImportSection)) { + return false; + } + ImportSection that = (ImportSection) o; + return Objects.equals(imports, that.imports); + } + + @Override + public int hashCode() { + return Objects.hashCode(imports); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Instruction.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Instruction.java new file mode 100644 index 000000000..60d166042 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Instruction.java @@ -0,0 +1,72 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.Arrays; +import java.util.Objects; + +public class Instruction { + public static final long[] EMPTY_OPERANDS = new long[0]; + + private final int address; + private final OpCode opcode; + private final long[] operands; + + public Instruction(int address, OpCode opcode, long[] operands) { + this.address = address; + this.opcode = opcode; + this.operands = operands.length == 0 ? EMPTY_OPERANDS : operands.clone(); + } + + public int address() { + return address; + } + + public OpCode opcode() { + return opcode; + } + + public long[] operands() { + return operands.clone(); + } + + public int operandCount() { + return operands.length; + } + + public long operand(int index) { + return operands[index]; + } + + // this is effectively internal API used to infer some operation's + // polymorphic type at validation time. + public void setOperand(int index, long value) { + operands[index] = value; + } + + @Override + public String toString() { + var result = String.format("0x%08X", address) + ": "; + if (operands.length > 0) { + return result + opcode + " " + Arrays.toString(operands); + } + return result + opcode.toString(); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof Instruction)) { + return false; + } + Instruction that = (Instruction) o; + return address == that.address + && opcode == that.opcode + && Objects.deepEquals(operands, that.operands); + } + + @Override + public int hashCode() { + return Objects.hash(address, opcode, Arrays.hashCode(operands)); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Memory.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Memory.java new file mode 100644 index 000000000..48c621083 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Memory.java @@ -0,0 +1,46 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.Objects; + +/** + * A memory definition. + *

+ * See Memories for + * reference. + */ +public final class Memory { + private final MemoryLimits limits; + + /** + * Construct a new instance. + * + * @param limits the memory limits (must not be {@code null}) + */ + public Memory(MemoryLimits limits) { + this.limits = Objects.requireNonNull(limits, "memoryLimits"); + } + + /** + * @return the defined memory limits + */ + public MemoryLimits limits() { + return limits; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof Memory)) { + return false; + } + Memory memory = (Memory) o; + return Objects.equals(limits, memory.limits); + } + + @Override + public int hashCode() { + return Objects.hashCode(limits); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MemoryImport.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MemoryImport.java new file mode 100644 index 000000000..e70106965 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MemoryImport.java @@ -0,0 +1,54 @@ +package com.dylibso.chicory.wasm.types; + +/** + * An imported memory. + */ +public final class MemoryImport extends Import { + private final MemoryLimits limits; + + /** + * Construct a new instance. + * + * @param moduleName the module name (must not be {@code null}) + * @param name the imported memory name (must not be {@code null}) + * @param limits the memory size limits (must not be {@code null}) + */ + public MemoryImport(String moduleName, String name, MemoryLimits limits) { + super(moduleName, name); + this.limits = limits; + } + + /** + * @return the memory size limits, in pages + */ + public MemoryLimits limits() { + return limits; + } + + @Override + public ExternalType importType() { + return ExternalType.MEMORY; + } + + @Override + public boolean equals(Import other) { + return other instanceof MemoryImport && equals((MemoryImport) other); + } + + public boolean equals(MemoryImport other) { + return this == other || super.equals(other) && limits.equals(other.limits); + } + + @Override + public int hashCode() { + return super.hashCode() * 19 + limits.hashCode(); + } + + @Override + public StringBuilder toString(StringBuilder b) { + b.append("memory (limits="); + limits.toString(b); + b.append(')'); + return super.toString(b); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MemoryLimits.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MemoryLimits.java new file mode 100644 index 000000000..b878db93b --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MemoryLimits.java @@ -0,0 +1,128 @@ +package com.dylibso.chicory.wasm.types; + +import com.dylibso.chicory.wasm.InvalidException; + +/** + * Limits for memory sizes, in pages. + *

+ * See Limits + * and Memories + * for reference. + */ +public final class MemoryLimits { + + /** + * Maximum allowed number of pages. + */ + public static final int MAX_PAGES = 1 << 16; + + private static final MemoryLimits DEFAULT_LIMITS = new MemoryLimits(0, MAX_PAGES); + + /** + * Initial number of pages. + */ + private final int initial; + + /** + * Maximum number of pages. + */ + private final int maximum; + + private final boolean shared; + + /** + * Construct a new instance. + * The maximum size will be {@link #MAX_PAGES}. + * + * @param initial the initial size, in pages + */ + public MemoryLimits(int initial) { + this(initial, MAX_PAGES); + } + + /** + * Construct a new instance. + * + * @param initial the initial size, in pages + * @param maximum the maximum size, in pages + */ + public MemoryLimits(int initial, int maximum) { + this(initial, maximum, false); + } + + /** + * Construct a new instance. + * + * @param initial the initial size, in pages + * @param maximum the maximum size, in pages + * @param shared if this memory is shared + */ + public MemoryLimits(int initial, int maximum, boolean shared) { + if (initial > MAX_PAGES || maximum > MAX_PAGES || initial < 0 || maximum < 0) { + throw new InvalidException("memory size must be at most 65536 pages (4GiB)"); + } + if (initial > maximum) { + throw new InvalidException("size minimum must not be greater than maximum"); + } + + this.initial = initial; + this.maximum = maximum; + this.shared = shared; + } + + /** + * @return the default memory limits + */ + public static MemoryLimits defaultLimits() { + return DEFAULT_LIMITS; + } + + /** + * @return the initial size, in pages + */ + public int initialPages() { + return initial; + } + + /** + * @return the maximum size, in pages + */ + public int maximumPages() { + return maximum; + } + + public boolean shared() { + return shared; + } + + @Override + public boolean equals(Object obj) { + return obj instanceof MemoryLimits && equals((MemoryLimits) obj); + } + + public boolean equals(MemoryLimits other) { + return this == other + || other != null && initial == other.initial && maximum == other.maximum; + } + + @Override + public int hashCode() { + return maximum * 19 + initial; + } + + @Override + public String toString() { + return toString(new StringBuilder()).toString(); + } + + public StringBuilder toString(StringBuilder b) { + b.append("[").append(initial).append(','); + if (maximum == MAX_PAGES) { + b.append("max"); + } else { + b.append(maximum); + } + b.append(']'); + return b; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MemorySection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MemorySection.java new file mode 100644 index 000000000..8be084520 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MemorySection.java @@ -0,0 +1,65 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public final class MemorySection extends Section { + private final List memories; + + private MemorySection(List memories) { + super(SectionId.MEMORY); + this.memories = List.copyOf(memories); + } + + public int memoryCount() { + return memories.size(); + } + + public Memory getMemory(int idx) { + return memories.get(idx); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List memories = new ArrayList<>(); + + private Builder() {} + + /** + * Add a memory definition to this section. + * + * @param memory the memory to add to this section (must not be {@code null}) + * @return the Builder + */ + public Builder addMemory(Memory memory) { + Objects.requireNonNull(memory, "memory"); + memories.add(memory); + return this; + } + + public MemorySection build() { + return new MemorySection(memories); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof MemorySection)) { + return false; + } + MemorySection that = (MemorySection) o; + return Objects.equals(memories, that.memories); + } + + @Override + public int hashCode() { + return Objects.hashCode(memories); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MutabilityType.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MutabilityType.java new file mode 100644 index 000000000..b2863fa08 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/MutabilityType.java @@ -0,0 +1,47 @@ +package com.dylibso.chicory.wasm.types; + +import com.dylibso.chicory.wasm.MalformedException; + +/** + * The kind of mutability for a global variable. + */ +public enum MutabilityType { + Const(ID.Const), + Var(ID.Var); + + private final int id; + + MutabilityType(int id) { + this.id = id; + } + + /** + * @return the numerical identifier for this type + */ + public int id() { + return id; + } + + /** + * @return the {@code MutabilityType} for the given ID value + * + * @throws IllegalArgumentException if the ID value does not correspond to a valid mutability type + */ + public static MutabilityType forId(int id) { + switch (id) { + case ID.Const: + return Const; + case ID.Var: + return Var; + default: + throw new MalformedException("Global malformed mutability"); + } + } + + static final class ID { + static final int Const = 0x00; + static final int Var = 0x01; + + private ID() {} + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/NameCustomSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/NameCustomSection.java new file mode 100644 index 000000000..e10c0e649 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/NameCustomSection.java @@ -0,0 +1,358 @@ +package com.dylibso.chicory.wasm.types; + +import static com.dylibso.chicory.wasm.Encoding.readName; +import static com.dylibso.chicory.wasm.Encoding.readVarUInt32; +import static java.util.Objects.requireNonNull; + +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.function.ToIntFunction; + +/** + * The "name" custom section. + */ +public final class NameCustomSection extends CustomSection { + + private final Optional moduleName; + private final List funcNames; + private final List> localNames; + private final List> labelNames; + private final List tableNames; + private final List memoryNames; + private final List globalNames; + private final List elementNames; + private final List dataNames; + private final List tagNames; + + private NameCustomSection( + Optional moduleName, + List funcNames, + List> localNames, + List> labelNames, + List tableNames, + List memoryNames, + List globalNames, + List elementNames, + List dataNames, + List tagNames) { + this.moduleName = requireNonNull(moduleName); + this.funcNames = List.copyOf(requireNonNull(funcNames)); + this.localNames = List.copyOf(requireNonNull(localNames)); + this.labelNames = List.copyOf(requireNonNull(labelNames)); + this.tableNames = List.copyOf(requireNonNull(tableNames)); + this.memoryNames = List.copyOf(requireNonNull(memoryNames)); + this.globalNames = List.copyOf(requireNonNull(globalNames)); + this.elementNames = List.copyOf(requireNonNull(elementNames)); + this.dataNames = List.copyOf(requireNonNull(dataNames)); + this.tagNames = List.copyOf(requireNonNull(tagNames)); + } + + /** + * Parse a new instance from a byte array. + * + * @param bytes the byte content of the section + */ + public static NameCustomSection parse(byte[] bytes) { + String moduleName = null; + List funcNames = new ArrayList<>(); + List> localNames = new ArrayList<>(); + List> labelNames = new ArrayList<>(); + List tableNames = new ArrayList<>(); + List memoryNames = new ArrayList<>(); + List globalNames = new ArrayList<>(); + List elementNames = new ArrayList<>(); + List dataNames = new ArrayList<>(); + List tagNames = new ArrayList<>(); + ByteBuffer buf = ByteBuffer.wrap(bytes); + + while (buf.hasRemaining()) { + byte id = buf.get(); + // discard subsection size + ByteBuffer slice = slice(buf, (int) readVarUInt32(buf)); + // todo: IDs 4 and 10 are reserved for the Host GC spec + switch (id) { + case 0: + assert (moduleName == null); + moduleName = readName(slice); + break; + case 1: + oneLevelParse(slice, funcNames); + break; + case 2: + twoLevelParse(slice, localNames); + break; + case 3: + twoLevelParse(slice, labelNames); + break; + case 5: + oneLevelParse(slice, tableNames); + break; + case 6: + oneLevelParse(slice, memoryNames); + break; + case 7: + oneLevelParse(slice, globalNames); + break; + case 8: + oneLevelParse(slice, elementNames); + break; + case 9: + oneLevelParse(slice, dataNames); + break; + case 11: + oneLevelParse(slice, tagNames); + break; + default: + // ignore unknown subsection for forwards-compatibility + } + } + + return new NameCustomSection( + Optional.ofNullable(moduleName), + funcNames, + localNames, + labelNames, + tableNames, + memoryNames, + globalNames, + elementNames, + dataNames, + tagNames); + } + + @Override + public String name() { + return "name"; + } + + /** + * @return the optional module name + */ + public Optional moduleName() { + return moduleName; + } + + /** + * @return the name of the function with the given index, or {@code null} if none is set + */ + public String nameOfFunction(int functionIdx) { + return oneLevelSearch(funcNames, functionIdx); + } + + /** + * @return the number of function names in this section + * This value does not have any relationship to the function index of any particular entry; + * it merely reflects the number of function names in this section. + * Used for testing. + */ + public int functionNameCount() { + return funcNames.size(); + } + + /** + * @return the name of the local with the given index within the function with the given index, or {@code null} if none is set + */ + public String nameOfLocal(int functionIdx, int localIdx) { + return twoLevelSearch(localNames, functionIdx, localIdx); + } + + /** + * @return the name of the local with the given index within the function with the given index, or {@code null} if none is set + */ + public String nameOfLabel(int functionIdx, int labelIdx) { + return twoLevelSearch(labelNames, functionIdx, labelIdx); + } + + /** + * @return the name of the table with the given index, or {@code null} if none is set + */ + public String nameOfTable(int tableIdx) { + return oneLevelSearch(tableNames, tableIdx); + } + + /** + * @return the name of the memory with the given index, or {@code null} if none is set + */ + public String nameOfMemory(int memoryIdx) { + return oneLevelSearch(memoryNames, memoryIdx); + } + + /** + * @return the name of the global with the given index, or {@code null} if none is set + */ + public String nameOfGlobal(int globalIdx) { + return oneLevelSearch(globalNames, globalIdx); + } + + /** + * @return the name of the element with the given index, or {@code null} if none is set + */ + public String nameOfElement(int elementIdx) { + return oneLevelSearch(elementNames, elementIdx); + } + + /** + * @return the name of the data segment with the given index, or {@code null} if none is set + */ + public String nameOfData(int dataIdx) { + return oneLevelSearch(dataNames, dataIdx); + } + + /** + * @return the name of the tag with the given index, or {@code null} if none is set + */ + public String nameOfTag(int tagIdx) { + return oneLevelSearch(tagNames, tagIdx); + } + + // parsing helpers + + private static void oneLevelParse(ByteBuffer slice, List list) { + int cnt = (int) readVarUInt32(slice); + for (int i = 0; i < cnt; i++) { + oneLevelStore(list, (int) readVarUInt32(slice), readName(slice)); + } + } + + private static void twoLevelParse(ByteBuffer slice, List> list) { + int listCnt = (int) readVarUInt32(slice); + for (int i = 0; i < listCnt; i++) { + int groupIdx = (int) readVarUInt32(slice); + int cnt = (int) readVarUInt32(slice); + for (int j = 0; j < cnt; j++) { + twoLevelStore(list, groupIdx, (int) readVarUInt32(slice), readName(slice)); + } + } + } + + private static ByteBuffer slice(ByteBuffer buf, int size) { + int pos = buf.position(); + int lim = buf.limit(); + try { + buf.limit(pos + size); + return buf.slice(); + } finally { + buf.limit(lim); + buf.position(pos + size); + } + } + + // searching + + private static String oneLevelSearch(List list, int searchIdx) { + int idx = binarySearch(list, searchIdx, NameEntry::index); + return idx < 0 ? null : list.get(idx).name(); + } + + private static String twoLevelSearch( + List> listList, int groupIdx, int subIdx) { + int fi = binarySearch(listList, groupIdx, ListEntry::index); + if (fi < 0) { + return null; + } + ListEntry subList = listList.get(fi); + int li = binarySearch(subList, subIdx, NameEntry::index); + return li < 0 ? null : subList.get(li).name; + } + + private static String oneLevelStore(List list, int storeIdx, String name) { + requireNonNull(name); + int idx = binarySearch(list, storeIdx, NameEntry::index); + if (idx < 0) { + // insert + list.add(-idx - 1, new NameEntry(storeIdx, name)); + return null; + } + // replace + return list.set(idx, new NameEntry(storeIdx, name)).name(); + } + + private static String twoLevelStore( + List> listList, int groupIdx, int subIdx, String name) { + requireNonNull(name); + int fi = binarySearch(listList, groupIdx, ListEntry::index); + ListEntry subList; + if (fi < 0) { + // insert + subList = new ListEntry<>(groupIdx); + listList.add(-fi - 1, subList); + } else { + subList = listList.get(fi); + } + int li = binarySearch(subList, subIdx, NameEntry::index); + if (li < 0) { + // insert + subList.add(-li - 1, new NameEntry(subIdx, name)); + return null; + } + // replace + return subList.set(li, new NameEntry(subIdx, name)).name(); + } + + private static int binarySearch(List list, int idx, ToIntFunction indexExtractor) { + int low = 0; + int high = list.size() - 1; + + while (low <= high) { + int mid = (low + high) >>> 1; + int cmp = Integer.compare(indexExtractor.applyAsInt(list.get(mid)), idx); + + if (cmp < 0) { + low = mid + 1; + } else if (cmp > 0) { + high = mid - 1; + } else { + // found + return mid; + } + } + // not found + return -low - 1; + } + + // name map support + + static final class NameEntry { + private final int index; + private final String name; + + NameEntry(int index, String name) { + this.index = index; + this.name = name; + } + + int index() { + return index; + } + + String name() { + return name; + } + + @Override + public String toString() { + return "[" + index + "] -> " + name; + } + } + + // this is never serialized. + @SuppressWarnings("serial") + static final class ListEntry extends ArrayList { + private final int index; + + ListEntry(int index) { + this.index = index; + } + + int index() { + return index; + } + + @Override + public String toString() { + return "[" + index + "] -> " + super.toString(); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/OpCode.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/OpCode.java new file mode 100644 index 000000000..6dc3b37a8 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/OpCode.java @@ -0,0 +1,568 @@ +package com.dylibso.chicory.wasm.types; + +import static com.dylibso.chicory.wasm.types.WasmEncoding.BLOCK_TYPE; +import static com.dylibso.chicory.wasm.types.WasmEncoding.BYTE; +import static com.dylibso.chicory.wasm.types.WasmEncoding.FLOAT32; +import static com.dylibso.chicory.wasm.types.WasmEncoding.FLOAT64; +import static com.dylibso.chicory.wasm.types.WasmEncoding.V128; +import static com.dylibso.chicory.wasm.types.WasmEncoding.VARSINT32; +import static com.dylibso.chicory.wasm.types.WasmEncoding.VARSINT64; +import static com.dylibso.chicory.wasm.types.WasmEncoding.VARUINT; +import static com.dylibso.chicory.wasm.types.WasmEncoding.VEC_CATCH; +import static com.dylibso.chicory.wasm.types.WasmEncoding.VEC_VALUE_TYPE; +import static com.dylibso.chicory.wasm.types.WasmEncoding.VEC_VARUINT; + +import java.util.List; + +public enum OpCode { + UNREACHABLE(0x00), + NOP(0x01), + BLOCK(0x02, List.of(BLOCK_TYPE)), + LOOP(0x03, List.of(BLOCK_TYPE)), + IF(0x04, List.of(BLOCK_TYPE)), + ELSE(0x05), + THROW(0x08, List.of(VARUINT)), + THROW_REF(0x0A), + END(0x0B), + BR(0x0C, List.of(VARUINT)), + BR_IF(0x0D, List.of(VARUINT)), + BR_TABLE(0x0E, List.of(VEC_VARUINT, VARUINT)), + RETURN(0x0F), + CALL(0x10, List.of(VARUINT)), + CALL_INDIRECT(0x11, List.of(VARUINT, VARUINT)), + RETURN_CALL(0x12, List.of(VARUINT)), + RETURN_CALL_INDIRECT(0x13, List.of(VARUINT, VARUINT)), + CALL_REF(0x14, List.of(VARUINT)), + RETURN_CALL_REF(0x15, List.of(VARUINT)), + DROP(0x1A), + SELECT(0x1B), + SELECT_T(0x1C, List.of(VEC_VALUE_TYPE)), + TRY_TABLE(0x1F, List.of(BLOCK_TYPE, VEC_CATCH)), + LOCAL_GET(0x20, List.of(VARUINT)), + LOCAL_SET(0x21, List.of(VARUINT)), + LOCAL_TEE(0x22, List.of(VARUINT)), + GLOBAL_GET(0x23, List.of(VARUINT)), + GLOBAL_SET(0x24, List.of(VARUINT)), + TABLE_GET(0x25, List.of(VARUINT)), + TABLE_SET(0x26, List.of(VARUINT)), + I32_LOAD(0x28, List.of(VARUINT, VARUINT)), + I64_LOAD(0x29, List.of(VARUINT, VARUINT)), + F32_LOAD(0x2A, List.of(VARUINT, VARUINT)), + F64_LOAD(0x2B, List.of(VARUINT, VARUINT)), + I32_LOAD8_S(0x2C, List.of(VARUINT, VARUINT)), + I32_LOAD8_U(0x2D, List.of(VARUINT, VARUINT)), + I32_LOAD16_S(0x2E, List.of(VARUINT, VARUINT)), + I32_LOAD16_U(0x2F, List.of(VARUINT, VARUINT)), + I64_LOAD8_S(0x30, List.of(VARUINT, VARUINT)), + I64_LOAD8_U(0x31, List.of(VARUINT, VARUINT)), + I64_LOAD16_S(0x32, List.of(VARUINT, VARUINT)), + I64_LOAD16_U(0x33, List.of(VARUINT, VARUINT)), + I64_LOAD32_S(0x34, List.of(VARUINT, VARUINT)), + I64_LOAD32_U(0x35, List.of(VARUINT, VARUINT)), + I32_STORE(0x36, List.of(VARUINT, VARUINT)), + I64_STORE(0x37, List.of(VARUINT, VARUINT)), + F32_STORE(0x38, List.of(VARUINT, VARUINT)), + F64_STORE(0x39, List.of(VARUINT, VARUINT)), + I32_STORE8(0x3A, List.of(VARUINT, VARUINT)), + I32_STORE16(0x3B, List.of(VARUINT, VARUINT)), + I64_STORE8(0x3C, List.of(VARUINT, VARUINT)), + I64_STORE16(0x3D, List.of(VARUINT, VARUINT)), + I64_STORE32(0x3E, List.of(VARUINT, VARUINT)), + MEMORY_SIZE(0x3F), + MEMORY_GROW(0x40), + I32_CONST(0x41, List.of(VARSINT32)), + I64_CONST(0x42, List.of(VARSINT64)), + F32_CONST(0x43, List.of(FLOAT32)), + F64_CONST(0x44, List.of(FLOAT64)), + I32_EQZ(0x45), + I32_EQ(0x46), + I32_NE(0x47), + I32_LT_S(0x48), + I32_LT_U(0x49), + I32_GT_S(0x4A), + I32_GT_U(0x4B), + I32_LE_S(0x4C), + I32_LE_U(0x4D), + I32_GE_S(0x4E), + I32_GE_U(0x4F), + I64_EQZ(0x50), + I64_EQ(0x51), + I64_NE(0x52), + I64_LT_S(0x53), + I64_LT_U(0x54), + I64_GT_S(0x55), + I64_GT_U(0x56), + I64_LE_S(0x57), + I64_LE_U(0x58), + I64_GE_S(0x59), + I64_GE_U(0x5A), + F32_EQ(0x5B), + F32_NE(0x5C), + F32_LT(0x5D), + F32_GT(0x5E), + F32_LE(0x5F), + F32_GE(0x60), + F64_EQ(0x61), + F64_NE(0x62), + F64_LT(0x63), + F64_GT(0x64), + F64_LE(0x65), + F64_GE(0x66), + I32_CLZ(0x67), + I32_CTZ(0x68), + I32_POPCNT(0x69), + I32_ADD(0x6A), + I32_SUB(0x6B), + I32_MUL(0x6C), + I32_DIV_S(0x6D), + I32_DIV_U(0x6E), + I32_REM_S(0x6F), + I32_REM_U(0x70), + I32_AND(0x71), + I32_OR(0x72), + I32_XOR(0x73), + I32_SHL(0x74), + I32_SHR_S(0x75), + I32_SHR_U(0x76), + I32_ROTL(0x77), + I32_ROTR(0x78), + I64_CLZ(0x79), + I64_CTZ(0x7A), + I64_POPCNT(0x7B), + I64_ADD(0x7C), + I64_SUB(0x7D), + I64_MUL(0x7E), + I64_DIV_S(0x7F), + I64_DIV_U(0x80), + I64_REM_S(0x81), + I64_REM_U(0x82), + I64_AND(0x83), + I64_OR(0x84), + I64_XOR(0x85), + I64_SHL(0x86), + I64_SHR_S(0x87), + I64_SHR_U(0x88), + I64_ROTL(0x89), + I64_ROTR(0x8A), + F32_ABS(0x8B), + F32_NEG(0x8C), + F32_CEIL(0x8D), + F32_FLOOR(0x8E), + F32_TRUNC(0x8F), + F32_NEAREST(0x90), + F32_SQRT(0x91), + F32_ADD(0x92), + F32_SUB(0x93), + F32_MUL(0x94), + F32_DIV(0x95), + F32_MIN(0x96), + F32_MAX(0x97), + F32_COPYSIGN(0x98), + F64_ABS(0x99), + F64_NEG(0x9A), + F64_CEIL(0x9B), + F64_FLOOR(0x9C), + F64_TRUNC(0x9D), + F64_NEAREST(0x9E), + F64_SQRT(0x9F), + F64_ADD(0xA0), + F64_SUB(0xA1), + F64_MUL(0xA2), + F64_DIV(0xA3), + F64_MIN(0xA4), + F64_MAX(0xA5), + F64_COPYSIGN(0xA6), + I32_WRAP_I64(0xA7), + I32_TRUNC_F32_S(0xA8), + I32_TRUNC_F32_U(0xA9), + I32_TRUNC_F64_S(0xAA), + I32_TRUNC_F64_U(0xAB), + I64_EXTEND_I32_S(0xAC), + I64_EXTEND_I32_U(0xAD), + I64_TRUNC_F32_S(0xAE), + I64_TRUNC_F32_U(0xAF), + I64_TRUNC_F64_S(0xB0), + I64_TRUNC_F64_U(0xB1), + F32_CONVERT_I32_S(0xB2), + F32_CONVERT_I32_U(0xB3), + F32_CONVERT_I64_S(0xB4), + F32_CONVERT_I64_U(0xB5), + F32_DEMOTE_F64(0xB6), + F64_CONVERT_I32_S(0xB7), + F64_CONVERT_I32_U(0xB8), + F64_CONVERT_I64_S(0xB9), + F64_CONVERT_I64_U(0xBA), + F64_PROMOTE_F32(0xBB), + I32_REINTERPRET_F32(0xBC), + I64_REINTERPRET_F64(0xBD), + F32_REINTERPRET_I32(0xBE), + F64_REINTERPRET_I64(0xBF), + I32_EXTEND_8_S(0xC0), + I32_EXTEND_16_S(0xC1), + I64_EXTEND_8_S(0xC2), + I64_EXTEND_16_S(0xC3), + I64_EXTEND_32_S(0xC4), + REF_NULL(0xD0, List.of(VARSINT32)), + REF_IS_NULL(0xD1), + REF_FUNC(0xD2, List.of(VARUINT)), + REF_AS_NON_NULL(0xD4), + BR_ON_NULL(0xD5, List.of(VARUINT)), + BR_ON_NON_NULL(0xD6, List.of(VARUINT)), + I32_TRUNC_SAT_F32_S(0xFC00), + I32_TRUNC_SAT_F32_U(0xFC01), + I32_TRUNC_SAT_F64_S(0xFC02), + I32_TRUNC_SAT_F64_U(0xFC03), + I64_TRUNC_SAT_F32_S(0xFC04), + I64_TRUNC_SAT_F32_U(0xFC05), + I64_TRUNC_SAT_F64_S(0xFC06), + I64_TRUNC_SAT_F64_U(0xFC07), + MEMORY_INIT(0xFC08, List.of(VARUINT, VARUINT)), + DATA_DROP(0xFC09, List.of(VARUINT)), + MEMORY_COPY(0xFC0A, List.of(VARUINT, VARUINT)), + MEMORY_FILL(0xFC0B, List.of(VARUINT)), + TABLE_INIT(0xFC0C, List.of(VARUINT, VARUINT)), + ELEM_DROP(0xFC0D, List.of(VARUINT)), + TABLE_COPY(0xFC0E, List.of(VARUINT, VARUINT)), + TABLE_GROW(0xFC0F, List.of(VARUINT)), + TABLE_SIZE(0xFC10, List.of(VARUINT)), + TABLE_FILL(0xFC11, List.of(VARUINT)), + V128_LOAD(0xFD00, List.of(VARUINT, VARUINT)), + V128_LOAD8x8_S(0xFD01, List.of(VARUINT, VARUINT)), + V128_LOAD8x8_U(0xFD02, List.of(VARUINT, VARUINT)), + V128_LOAD16x4_S(0xFD03, List.of(VARUINT, VARUINT)), + V128_LOAD16x4_U(0xFD04, List.of(VARUINT, VARUINT)), + V128_LOAD32x2_S(0xFD05, List.of(VARUINT, VARUINT)), + V128_LOAD32x2_U(0xFD06, List.of(VARUINT, VARUINT)), + V128_LOAD8_SPLAT(0xFD07, List.of(VARUINT, VARUINT)), + V128_LOAD16_SPLAT(0xFD08, List.of(VARUINT, VARUINT)), + V128_LOAD32_SPLAT(0xFD09, List.of(VARUINT, VARUINT)), + V128_LOAD64_SPLAT(0xFD0A, List.of(VARUINT, VARUINT)), + V128_STORE(0xFD0B, List.of(VARUINT, VARUINT)), + V128_CONST(0xFD0C, List.of(V128)), + I8x16_SHUFFLE(0xFD0D, List.of(V128)), + I8x16_SWIZZLE(0xFD0E), + I8x16_SPLAT(0xFD0F), + I16x8_SPLAT(0xFD10), + I32x4_SPLAT(0xFD11), + I64x2_SPLAT(0xFD12), + F32x4_SPLAT(0xFD13), + F64x2_SPLAT(0xFD14), + I8x16_EXTRACT_LANE_S(0xFD15, List.of(BYTE)), + I8x16_EXTRACT_LANE_U(0xFD16, List.of(BYTE)), + I8x16_REPLACE_LANE(0xFD17, List.of(BYTE)), + I16x8_EXTRACT_LANE_S(0xFD18, List.of(BYTE)), + I16x8_EXTRACT_LANE_U(0xFD19, List.of(BYTE)), + I16x8_REPLACE_LANE(0xFD1A, List.of(BYTE)), + I32x4_EXTRACT_LANE(0xFD1B, List.of(BYTE)), + I32x4_REPLACE_LANE(0xFD1C, List.of(BYTE)), + I64x2_EXTRACT_LANE(0xFD1D, List.of(BYTE)), + I64x2_REPLACE_LANE(0xFD1E, List.of(BYTE)), + F32x4_EXTRACT_LANE(0xFD1F, List.of(BYTE)), + F32x4_REPLACE_LANE(0xFD20, List.of(BYTE)), + F64x2_EXTRACT_LANE(0xFD21, List.of(BYTE)), + F64x2_REPLACE_LANE(0xFD22, List.of(BYTE)), + I8x16_EQ(0xFD23), + I8x16_NE(0xFD24), + I8x16_LT_S(0xFD25), + I8x16_LT_U(0xFD26), + I8x16_GT_S(0xFD27), + I8x16_GT_U(0xFD28), + I8x16_LE_S(0xFD29), + I8x16_LE_U(0xFD2A), + I8x16_GE_S(0xFD2B), + I8x16_GE_U(0xFD2C), + I16x8_EQ(0xFD2D), + I16x8_NE(0xFD2E), + I16x8_LT_S(0xFD2F), + I16x8_LT_U(0xFD30), + I16x8_GT_S(0xFD31), + I16x8_GT_U(0xFD32), + I16x8_LE_S(0xFD33), + I16x8_LE_U(0xFD34), + I16x8_GE_S(0xFD35), + I16x8_GE_U(0xFD36), + I32x4_EQ(0xFD37), + I32x4_NE(0xFD38), + I32x4_LT_S(0xFD39), + I32x4_LT_U(0xFD3A), + I32x4_GT_S(0xFD3B), + I32x4_GT_U(0xFD3C), + I32x4_LE_S(0xFD3D), + I32x4_LE_U(0xFD3E), + I32x4_GE_S(0xFD3F), + I32x4_GE_U(0xFD40), + F32x4_EQ(0xFD41), + F32x4_NE(0xFD42), + F32x4_LT(0xFD43), + F32x4_GT(0xFD44), + F32x4_LE(0xFD45), + F32x4_GE(0xFD46), + F64x2_EQ(0xFD47), + F64x2_NE(0xFD48), + F64x2_LT(0xFD49), + F64x2_GT(0xFD4A), + F64x2_LE(0xFD4B), + F64x2_GE(0xFD4C), + V128_NOT(0xFD4D), + V128_AND(0xFD4E), + V128_ANDNOT(0xFD4F), + V128_OR(0xFD50), + V128_XOR(0xFD51), + V128_BITSELECT(0xFD52), + V128_ANY_TRUE(0xFD53), + V128_LOAD8_LANE(0xFD54, List.of(VARUINT, VARUINT, VARUINT)), + V128_LOAD16_LANE(0xFD55, List.of(VARUINT, VARUINT, VARUINT)), + V128_LOAD32_LANE(0xFD56, List.of(VARUINT, VARUINT, VARUINT)), + V128_LOAD64_LANE(0xFD57, List.of(VARUINT, VARUINT, VARUINT)), + V128_STORE8_LANE(0xFD58, List.of(VARUINT, VARUINT, VARUINT)), + V128_STORE16_LANE(0xFD59, List.of(VARUINT, VARUINT, VARUINT)), + V128_STORE32_LANE(0xFD5A, List.of(VARUINT, VARUINT, VARUINT)), + V128_STORE64_LANE(0xFD5B, List.of(VARUINT, VARUINT, VARUINT)), + V128_LOAD32_ZERO(0xFD5C, List.of(VARUINT, VARUINT)), + V128_LOAD64_ZERO(0xFD5D, List.of(VARUINT, VARUINT)), + F32x4_DEMOTE_LOW_F64x2_ZERO(0xFD5E), + F64x2_PROMOTE_LOW_F32x4(0xFD5F), + I8x16_ABS(0xFD60), + I8x16_NEG(0xFD61), + I8x16_POPCNT(0xFD62), + I8x16_ALL_TRUE(0xFD63), + I8x16_BITMASK(0xFD64), + I8x16_NARROW_I16x8_S(0xFD65), + I8x16_NARROW_I16x8_U(0xFD66), + F32x4_CEIL(0xFD67), + F32x4_FLOOR(0xFD68), + F32x4_TRUNC(0xFD69), + F32x4_NEAREST(0xFD6A), + I8x16_SHL(0xFD6B), + I8x16_SHR_S(0xFD6C), + I8x16_SHR_U(0xFD6D), + I8x16_ADD(0xFD6E), + I8x16_ADD_SAT_S(0xFD6F), + I8x16_ADD_SAT_U(0xFD70), + I8x16_SUB(0xFD71), + I8x16_SUB_SAT_S(0xFD72), + I8x16_SUB_SAT_U(0xFD73), + F64x2_CEIL(0xFD74), + F64x2_FLOOR(0xFD75), + I8x16_MIN_S(0xFD76), + I8x16_MIN_U(0xFD77), + I8x16_MAX_S(0xFD78), + I8x16_MAX_U(0xFD79), + F64x2_TRUNC(0xFD7A), + I8x16_AVGR_U(0xFD7B), + I16x8_EXTADD_PAIRWISE_I8x16_S(0xFD7C), + I16x8_EXTADD_PAIRWISE_I8x16_U(0xFD7D), + I32x4_EXTADD_PAIRWISE_I16x8_S(0xFD7E), + I32x4_EXTADD_PAIRWISE_I16x8_U(0xFD7F), + I16x8_ABS(0xFD80), + I16x8_NEG(0xFD81), + I16x8_Q15MULR_SAT_S(0xFD82), + I16x8_ALL_TRUE(0xFD83), + I16x8_BITMASK(0xFD84), + I16x8_NARROW_I32x4_S(0xFD85), + I16x8_NARROW_I32x4_U(0xFD86), + I16x8_EXTEND_LOW_I8x16_S(0xFD87), + I16x8_EXTEND_HIGH_I8x16_S(0xFD88), + I16x8_EXTEND_LOW_I8x16_U(0xFD89), + I16x8_EXTEND_HIGH_I8x16_U(0xFD8A), + I16x8_SHL(0xFD8B), + I16x8_SHR_S(0xFD8C), + I16x8_SHR_U(0xFD8D), + I16x8_ADD(0xFD8E), + I16x8_ADD_SAT_S(0xFD8F), + I16x8_ADD_SAT_U(0xFD90), + I16x8_SUB(0xFD91), + I16x8_SUB_SAT_S(0xFD92), + I16x8_SUB_SAT_U(0xFD93), + F64x2_NEAREST(0xFD94), + I16x8_MUL(0xFD95), + I16x8_MIN_S(0xFD96), + I16x8_MIN_U(0xFD97), + I16x8_MAX_S(0xFD98), + I16x8_MAX_U(0xFD99), + I16x8_AVGR_U(0xFD9B), + I16x8_EXTMUL_LOW_I8x16_S(0xFD9C), + I16x8_EXTMUL_HIGH_I8x16_S(0xFD9D), + I16x8_EXTMUL_LOW_I8x16_U(0xFD9E), + I16x8_EXTMUL_HIGH_I8x16_U(0xFD9F), + I32x4_ABS(0xFDA0), + I32x4_NEG(0xFDA1), + I32x4_ALL_TRUE(0xFDA3), + I32x4_BITMASK(0xFDA4), + I32x4_EXTEND_LOW_I16x8_S(0xFDA7), + I32x4_EXTEND_HIGH_I16x8_S(0xFDA8), + I32x4_EXTEND_LOW_I16x8_U(0xFDA9), + I32x4_EXTEND_HIGH_I16x8_U(0xFDAA), + I32x4_SHL(0xFDAB), + I32x4_SHR_S(0xFDAC), + I32x4_SHR_U(0xFDAD), + I32x4_ADD(0xFDAE), + I32x4_SUB(0xFDB1), + I32x4_MUL(0xFDB5), + I32x4_MIN_S(0xFDB6), + I32x4_MIN_U(0xFDB7), + I32x4_MAX_S(0xFDB8), + I32x4_MAX_U(0xFDB9), + I32x4_DOT_I16x8_S(0xFDBA), + I32x4_EXTMUL_LOW_I16x8_S(0xFDBC), + I32x4_EXTMUL_HIGH_I16x8_S(0xFDBD), + I32x4_EXTMUL_LOW_I16x8_U(0xFDBE), + I32x4_EXTMUL_HIGH_I16x8_U(0xFDBF), + I64x2_ABS(0xFDC0), + I64x2_NEG(0xFDC1), + I64x2_ALL_TRUE(0xFDC3), + I64x2_BITMASK(0xFDC4), + I64x2_EXTEND_LOW_I32x4_S(0xFDC7), + I64x2_EXTEND_HIGH_I32x4_S(0xFDC8), + I64x2_EXTEND_LOW_I32x4_U(0xFDC9), + I64x2_EXTEND_HIGH_I32x4_U(0xFDCA), + I64x2_SHL(0xFDCB), + I64x2_SHR_S(0xFDCC), + I64x2_SHR_U(0xFDCD), + I64x2_ADD(0xFDCE), + I64x2_SUB(0xFDD1), + I64x2_MUL(0xFDD5), + I64x2_EQ(0xFDD6), + I64x2_NE(0xFDD7), + I64x2_LT_S(0xFDD8), + I64x2_GT_S(0xFDD9), + I64x2_LE_S(0xFDDA), + I64x2_GE_S(0xFDDB), + I64x2_EXTMUL_LOW_I32x4_S(0xFDDC), + I64x2_EXTMUL_HIGH_I32x4_S(0xFDDD), + I64x2_EXTMUL_LOW_I32x4_U(0xFDDE), + I64x2_EXTMUL_HIGH_I32x4_U(0xFDDF), + F32x4_ABS(0xFDE0), + F32x4_NEG(0xFDE1), + F32x4_SQRT(0xFDE3), + F32x4_ADD(0xFDE4), + F32x4_SUB(0xFDE5), + F32x4_MUL(0xFDE6), + F32x4_DIV(0xFDE7), + F32x4_MIN(0xFDE8), + F32x4_MAX(0xFDE9), + F32x4_PMIN(0xFDEA), + F32x4_PMAX(0xFDEB), + F64x2_ABS(0xFDEC), + F64x2_NEG(0xFDED), + F64x2_SQRT(0xFDEF), + F64x2_ADD(0xFDF0), + F64x2_SUB(0xFDF1), + F64x2_MUL(0xFDF2), + F64x2_DIV(0xFDF3), + F64x2_MIN(0xFDF4), + F64x2_MAX(0xFDF5), + F64x2_PMIN(0xFDF6), + F64x2_PMAX(0xFDF7), + I32x4_TRUNC_SAT_F32X4_S(0xFDF8), + I32x4_TRUNC_SAT_F32X4_U(0xFDF9), + F32x4_CONVERT_I32x4_S(0xFDFA), + F32x4_CONVERT_I32x4_U(0xFDFB), + I32x4_TRUNC_SAT_F64x2_S_ZERO(0xFDFC), + I32x4_TRUNC_SAT_F64x2_U_ZERO(0xFDFD), + F64x2_CONVERT_LOW_I32x4_S(0xFDFE), + F64x2_CONVERT_LOW_I32x4_U(0xFDFF), + MEM_ATOMIC_NOTIFY(0xFE00, List.of(BYTE, VARUINT)), + MEM_ATOMIC_WAIT32(0xFE01, List.of(BYTE, VARUINT)), + MEM_ATOMIC_WAIT64(0xFE02, List.of(BYTE, VARUINT)), + ATOMIC_FENCE(0xFE03, List.of(BYTE)), + I32_ATOMIC_LOAD(0xFE10, List.of(BYTE, VARUINT)), + I64_ATOMIC_LOAD(0xFE11, List.of(BYTE, VARUINT)), + I32_ATOMIC_LOAD8_U(0xFE12, List.of(BYTE, VARUINT)), + I32_ATOMIC_LOAD16_U(0xFE13, List.of(BYTE, VARUINT)), + I64_ATOMIC_LOAD8_U(0xFE14, List.of(BYTE, VARUINT)), + I64_ATOMIC_LOAD16_U(0xFE15, List.of(BYTE, VARUINT)), + I64_ATOMIC_LOAD32_U(0xFE16, List.of(BYTE, VARUINT)), + I32_ATOMIC_STORE(0xFE17, List.of(BYTE, VARUINT)), + I64_ATOMIC_STORE(0xFE18, List.of(BYTE, VARUINT)), + I32_ATOMIC_STORE8(0xFE19, List.of(BYTE, VARUINT)), + I32_ATOMIC_STORE16(0xFE1A, List.of(BYTE, VARUINT)), + I64_ATOMIC_STORE8(0xFE1B, List.of(BYTE, VARUINT)), + I64_ATOMIC_STORE16(0xFE1C, List.of(BYTE, VARUINT)), + I64_ATOMIC_STORE32(0xFE1D, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW_ADD(0xFE1E, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW_ADD(0xFE1F, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW8_ADD_U(0xFE20, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW16_ADD_U(0xFE21, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW8_ADD_U(0xFE22, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW16_ADD_U(0xFE23, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW32_ADD_U(0xFE24, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW_SUB(0xFE25, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW_SUB(0xFE26, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW8_SUB_U(0xFE27, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW16_SUB_U(0xFE28, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW8_SUB_U(0xFE29, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW16_SUB_U(0xFE2A, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW32_SUB_U(0xFE2B, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW_AND(0xFE2C, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW_AND(0xFE2D, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW8_AND_U(0xFE2E, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW16_AND_U(0xFE2F, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW8_AND_U(0xFE30, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW16_AND_U(0xFE31, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW32_AND_U(0xFE32, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW_OR(0xFE33, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW_OR(0xFE34, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW8_OR_U(0xFE35, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW16_OR_U(0xFE36, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW8_OR_U(0xFE37, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW16_OR_U(0xFE38, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW32_OR_U(0xFE39, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW_XOR(0xFE3A, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW_XOR(0xFE3B, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW8_XOR_U(0xFE3C, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW16_XOR_U(0xFE3D, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW8_XOR_U(0xFE3E, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW16_XOR_U(0xFE3F, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW32_XOR_U(0xFE40, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW_XCHG(0xFE41, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW_XCHG(0xFE42, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW8_XCHG_U(0xFE43, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW16_XCHG_U(0xFE44, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW8_XCHG_U(0xFE45, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW16_XCHG_U(0xFE46, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW32_XCHG_U(0xFE47, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW_CMPXCHG(0xFE48, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW_CMPXCHG(0xFE49, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW8_CMPXCHG_U(0xFE4A, List.of(BYTE, VARUINT)), + I32_ATOMIC_RMW16_CMPXCHG_U(0xFE4B, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW8_CMPXCHG_U(0xFE4C, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW16_CMPXCHG_U(0xFE4D, List.of(BYTE, VARUINT)), + I64_ATOMIC_RMW32_CMPXCHG_U(0xFE4E, List.of(BYTE, VARUINT)), + ; + + private static final int OP_CODES_SIZE = 0xFF00; + + // trick: the enum constructor cannot access its own static fields + // but can access another class + private static final class OpCodes { + private OpCodes() {} + + private static final OpCode[] byOpCode = new OpCode[OP_CODES_SIZE]; + private static final List[] signatures = new List[OP_CODES_SIZE]; + } + + private final int opcode; + + OpCode(int opcode) { + this(opcode, List.of()); + } + + OpCode(int opcode, List signature) { + this.opcode = opcode; + OpCodes.byOpCode[opcode] = this; + OpCodes.signatures[opcode] = signature; + } + + public int opcode() { + return opcode; + } + + public static OpCode byOpCode(int opcode) { + return OpCodes.byOpCode[opcode]; + } + + public static List signature(OpCode opcode) { + return OpCodes.signatures[opcode.opcode()]; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/PassiveDataSegment.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/PassiveDataSegment.java new file mode 100644 index 000000000..2949fb516 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/PassiveDataSegment.java @@ -0,0 +1,9 @@ +package com.dylibso.chicory.wasm.types; + +public final class PassiveDataSegment extends DataSegment { + public static final PassiveDataSegment EMPTY = new PassiveDataSegment(new byte[] {}); + + public PassiveDataSegment(byte[] data) { + super(data); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/PassiveElement.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/PassiveElement.java new file mode 100644 index 000000000..1b5957307 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/PassiveElement.java @@ -0,0 +1,20 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.List; + +/** + * A passive element. + * A passive element can be copied into a table using the {@code table.init} instruction. + */ +public final class PassiveElement extends Element { + + /** + * Construct a new instance. + * + * @param type the type of the element values (must not be {@code null}) + * @param initializers the list of instruction lists which are used to initialize each element in the range (must not be {@code null}) + */ + public PassiveElement(ValType type, List> initializers) { + super(type, initializers); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/RawSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/RawSection.java new file mode 100644 index 000000000..f57748c6a --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/RawSection.java @@ -0,0 +1,14 @@ +package com.dylibso.chicory.wasm.types; + +public class RawSection extends Section { + private final byte[] contents; + + public RawSection(long id, byte[] contents) { + super(id); + this.contents = contents.clone(); + } + + public byte[] contents() { + return contents.clone(); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Section.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Section.java new file mode 100644 index 000000000..b09c6ce19 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Section.java @@ -0,0 +1,13 @@ +package com.dylibso.chicory.wasm.types; + +public abstract class Section { + private final int id; + + Section(long id) { + this.id = (int) id; + } + + public int sectionId() { + return id; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/SectionId.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/SectionId.java new file mode 100644 index 000000000..e4e145c2b --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/SectionId.java @@ -0,0 +1,20 @@ +package com.dylibso.chicory.wasm.types; + +public final class SectionId { + public static final int CUSTOM = 0; + public static final int TYPE = 1; + public static final int IMPORT = 2; + public static final int FUNCTION = 3; + public static final int TABLE = 4; + public static final int MEMORY = 5; + public static final int GLOBAL = 6; + public static final int EXPORT = 7; + public static final int START = 8; + public static final int ELEMENT = 9; + public static final int CODE = 10; + public static final int DATA = 11; + public static final int DATA_COUNT = 12; + public static final int TAG = 13; + + private SectionId() {} +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/StartSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/StartSection.java new file mode 100644 index 000000000..cc03dc53e --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/StartSection.java @@ -0,0 +1,50 @@ +package com.dylibso.chicory.wasm.types; + +public final class StartSection extends Section { + private final long startIndex; + + private StartSection(long startIndex) { + super(SectionId.START); + this.startIndex = startIndex; + } + + public long startIndex() { + return startIndex; + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private long startIndex; + + private Builder() {} + + public Builder setStartIndex(long startIndex) { + this.startIndex = startIndex; + return this; + } + + public StartSection build() { + return new StartSection(startIndex); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof StartSection)) { + return false; + } + StartSection that = (StartSection) o; + return startIndex == that.startIndex; + } + + @Override + public int hashCode() { + return Long.hashCode(startIndex); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Table.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Table.java new file mode 100644 index 000000000..6627f6089 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Table.java @@ -0,0 +1,70 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.List; +import java.util.Objects; + +public class Table { + private final ValType elementType; + private final TableLimits limits; + private final List init; + + public Table(ValType elementType, TableLimits limits) { + this( + elementType, + limits, + List.of(new Instruction(-1, OpCode.REF_NULL, new long[] {elementType.typeIdx()}))); + } + + /** + * @deprecated use {@link #Table(ValType, TableLimits)} + */ + @Deprecated(since = "1.3.0") + public Table(ValueType elementType, TableLimits limits) { + this( + elementType.toValType(), + limits, + List.of( + new Instruction( + -1, + OpCode.REF_NULL, + new long[] {elementType.toValType().typeIdx()}))); + } + + public Table(ValType elementType, TableLimits limits, List init) { + this.elementType = Objects.requireNonNull(elementType, "elementType"); + if (!elementType.isReference()) { + throw new IllegalArgumentException("Table element type must be a reference type"); + } + this.limits = Objects.requireNonNull(limits, "limits"); + this.init = init; + } + + public ValType elementType() { + return elementType; + } + + public TableLimits limits() { + return limits; + } + + public List initialize() { + return init; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof Table)) { + return false; + } + Table table = (Table) o; + return elementType.equals(table.elementType) && Objects.equals(limits, table.limits); + } + + @Override + public int hashCode() { + return Objects.hash(elementType, limits); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TableImport.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TableImport.java new file mode 100644 index 000000000..e38bf3f65 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TableImport.java @@ -0,0 +1,79 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.Objects; + +/** + * An imported table. + */ +public final class TableImport extends Import { + private final ValType entryType; + private final TableLimits limits; + + /** + * Construct a new instance. + * + * @param moduleName the module name (must not be {@code null}) + * @param name the imported table name (must not be {@code null}) + * @param entryType the table entry type (must not be {@code null}) + * @param limits the table limits (must not be {@code null}) + */ + public TableImport(String moduleName, String name, ValType entryType, TableLimits limits) { + super(moduleName, name); + this.entryType = Objects.requireNonNull(entryType, "entryType"); + this.limits = Objects.requireNonNull(limits, "limits"); + } + + /** + * @deprecated use {@link #TableImport(String, String, ValType, TableLimits)} + */ + @Deprecated(since = "1.3.0") + public TableImport(String moduleName, String name, ValueType entryType, TableLimits limits) { + super(moduleName, name); + this.entryType = Objects.requireNonNull(entryType, "entryType").toValType(); + this.limits = Objects.requireNonNull(limits, "limits"); + } + + /** + * @return the table entry type + */ + public ValType entryType() { + return entryType; + } + + /** + * @return the table size limits + */ + public TableLimits limits() { + return limits; + } + + @Override + public ExternalType importType() { + return ExternalType.TABLE; + } + + @Override + public boolean equals(Import other) { + return other instanceof TableImport && equals((TableImport) other); + } + + public boolean equals(TableImport other) { + return this == other + || super.equals(other) + && entryType == other.entryType + && limits.equals(other.limits); + } + + @Override + public int hashCode() { + return (super.hashCode() * 19 + entryType.hashCode()) * 19 + limits.hashCode(); + } + + @Override + public StringBuilder toString(StringBuilder b) { + b.append("table (type=").append(entryType).append(",limits="); + limits.toString(b); + b.append(')'); + return super.toString(b); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TableLimits.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TableLimits.java new file mode 100644 index 000000000..573769407 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TableLimits.java @@ -0,0 +1,81 @@ +package com.dylibso.chicory.wasm.types; + +import static com.dylibso.chicory.wasm.WasmLimits.MAX_TABLE_ENTRIES; + +import com.dylibso.chicory.wasm.InvalidException; + +public class TableLimits { + public static final long LIMIT_MAX = MAX_TABLE_ENTRIES; + + private static final TableLimits UNBOUNDED = new TableLimits(0); + + private long min; + private final long max; + private final boolean shared; + + public TableLimits(long min) { + this(min, LIMIT_MAX); + } + + public TableLimits(long min, long max) { + this(min, max, false); + } + + public TableLimits(long min, long max, boolean shared) { + if (min > max) { + throw new InvalidException("size minimum must not be greater than maximum"); + } + this.min = Math.min(Math.max(0, min), LIMIT_MAX); + this.max = Math.min(max, LIMIT_MAX); + this.shared = shared; + } + + public void grow(int size) { + min += size; + } + + public long min() { + return min; + } + + public long max() { + return max; + } + + public boolean shared() { + return shared; + } + + @Override + public boolean equals(Object obj) { + return obj instanceof TableLimits && equals((TableLimits) obj); + } + + public boolean equals(TableLimits other) { + return this == other || other != null && min == other.min && max == other.max; + } + + @Override + public int hashCode() { + return Long.hashCode(min) * 19 + Long.hashCode(max); + } + + @Override + public String toString() { + return toString(new StringBuilder()).toString(); + } + + public StringBuilder toString(StringBuilder b) { + b.append("[").append(min).append(','); + if (max == LIMIT_MAX) { + b.append("max"); + } else { + b.append(max); + } + return b.append(']'); + } + + public static TableLimits unbounded() { + return UNBOUNDED; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TableSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TableSection.java new file mode 100644 index 000000000..7f1c9a19b --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TableSection.java @@ -0,0 +1,65 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public final class TableSection extends Section { + private final List tables; + + private TableSection(List
tables) { + super(SectionId.TABLE); + this.tables = List.copyOf(tables); + } + + public int tableCount() { + return tables.size(); + } + + public Table getTable(int idx) { + return tables.get(idx); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List
tables = new ArrayList<>(); + + private Builder() {} + + /** + * Add a table definition to this section. + * + * @param table the table to add to this section (must not be {@code null}) + * @return the Builder + */ + public Builder addTable(Table table) { + Objects.requireNonNull(table, "table"); + tables.add(table); + return this; + } + + public TableSection build() { + return new TableSection(tables); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof TableSection)) { + return false; + } + TableSection that = (TableSection) o; + return Objects.equals(tables, that.tables); + } + + @Override + public int hashCode() { + return Objects.hashCode(tables); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TagImport.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TagImport.java new file mode 100644 index 000000000..3748fc968 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TagImport.java @@ -0,0 +1,49 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.Objects; + +/** + * An imported table. + */ +public final class TagImport extends Import { + private final TagType tagType; + + public TagImport(String moduleName, String name, byte attribute, int tagTypeIdx) { + super(moduleName, name); + this.tagType = new TagType(attribute, tagTypeIdx); + } + + public TagType tagType() { + return tagType; + } + + @Override + public ExternalType importType() { + return ExternalType.TAG; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + if (!super.equals(o)) { + return false; + } + TagImport tagImport = (TagImport) o; + return Objects.equals(tagType, tagImport.tagType); + } + + @Override + public int hashCode() { + return Objects.hash(super.hashCode(), tagType); + } + + @Override + public String toString() { + return "TagImport{" + "tagType=" + tagType + '}'; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TagSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TagSection.java new file mode 100644 index 000000000..7faccab8e --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TagSection.java @@ -0,0 +1,63 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public final class TagSection extends Section { + private final List tags; + + private TagSection(List tags) { + super(SectionId.TAG); + this.tags = List.copyOf(tags); + } + + public TagType[] types() { + return tags.toArray(new TagType[0]); + } + + public int tagCount() { + return tags.size(); + } + + public TagType getTag(int idx) { + return tags.get(idx); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List tags = new ArrayList<>(); + + private Builder() {} + + public Builder addTagType(TagType tagType) { + Objects.requireNonNull(tagType, "tagType"); + tags.add(tagType); + return this; + } + + public TagSection build() { + return new TagSection(tags); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof TagSection)) { + return false; + } + TagSection that = (TagSection) o; + return Objects.equals(tags, that.tags); + } + + @Override + public int hashCode() { + return Objects.hashCode(tags); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TagType.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TagType.java new file mode 100644 index 000000000..e8e435559 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TagType.java @@ -0,0 +1,19 @@ +package com.dylibso.chicory.wasm.types; + +public class TagType { + private final byte attribute; + private final int typeIdx; + + public TagType(byte attribute, int typeIdx) { + this.attribute = attribute; + this.typeIdx = typeIdx; + } + + public byte attribute() { + return attribute; + } + + public int typeIdx() { + return typeIdx; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TypeSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TypeSection.java new file mode 100644 index 000000000..9fe578fef --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/TypeSection.java @@ -0,0 +1,73 @@ +package com.dylibso.chicory.wasm.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public final class TypeSection extends Section { + private final List types; + + private TypeSection(List types) { + super(SectionId.TYPE); + this.types = List.copyOf(types); + } + + public FunctionType[] types() { + return types.toArray(new FunctionType[0]); + } + + public int typeCount() { + return types.size(); + } + + public FunctionType getType(int idx) { + return types.get(idx); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private final List types = new ArrayList<>(); + + private Builder() {} + + public List getTypes() { + return types; + } + + /** + * Add a function type definition to this section. + * + * @param functionType the function type to add to this section (must not be {@code null}) + * @return the Builder + */ + public Builder addFunctionType(FunctionType functionType) { + Objects.requireNonNull(functionType, "functionType"); + types.add(functionType); + return this; + } + + public TypeSection build() { + return new TypeSection(types); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || !(o instanceof TypeSection)) { + return false; + } + TypeSection that = (TypeSection) o; + return Objects.equals(types, that.types); + } + + @Override + public int hashCode() { + return Objects.hashCode(types); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/UnknownCustomSection.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/UnknownCustomSection.java new file mode 100644 index 000000000..5a41e8b48 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/UnknownCustomSection.java @@ -0,0 +1,50 @@ +package com.dylibso.chicory.wasm.types; + +import static java.util.Objects.requireNonNull; + +/** + * A custom section which is unknown to the parser. + */ +public final class UnknownCustomSection extends CustomSection { + private final String name; + private final byte[] bytes; + + private UnknownCustomSection(String name, byte[] bytes) { + this.name = requireNonNull(name, "name"); + this.bytes = bytes.clone(); + } + + @Override + public String name() { + return name; + } + + public byte[] bytes() { + return bytes.clone(); + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private String name; + private byte[] bytes; + + private Builder() {} + + public Builder withName(String name) { + this.name = requireNonNull(name); + return this; + } + + public Builder withBytes(byte[] bytes) { + this.bytes = requireNonNull(bytes); + return this; + } + + public UnknownCustomSection build() { + return new UnknownCustomSection(name, bytes); + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ValType.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ValType.java new file mode 100644 index 000000000..a64555639 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ValType.java @@ -0,0 +1,441 @@ +package com.dylibso.chicory.wasm.types; + +import com.dylibso.chicory.wasm.ChicoryException; +import com.dylibso.chicory.wasm.InvalidException; +import java.util.List; +import java.util.Objects; +import java.util.function.Function; + +/** + * The possible WASM value types. + */ +public final class ValType { + private static final int NULL_TYPEIDX = 0; + private static final long OPCODE_MASK = 0xFFFFFFFFL; + private static final long TYPEIDX_SHIFT = 32; + + public static ValType BOT = new ValType(ID.BOT); + public static ValType F64 = new ValType(ID.F64); + + public static ValType F32 = new ValType(ID.F32); + public static ValType I64 = new ValType(ID.I64); + + public static ValType I32 = new ValType(ID.I32); + + public static ValType V128 = new ValType(ID.V128); + public static ValType FuncRef = new ValType(ID.FuncRef); + public static ValType ExnRef = new ValType(ID.ExnRef); + public static ValType ExternRef = new ValType(ID.ExternRef); + + public static ValType RefBot = new ValType(ValType.ID.Ref, ValType.TypeIdxCode.BOT.code()); + + private final long id; + + // defined function type. This is not representable in the binary or textual representation + // of WASM. This is instead used after substitution to represent closed ValType. + // This is useful when validating import function values. + private final FunctionType resolvedFunctionType; + + private ValType(int opcode) { + this(opcode, NULL_TYPEIDX, null); + } + + private ValType(int opcode, int typeIdx) { + this(opcode, typeIdx, null); + } + + private ValType(int opcode, int typeIdx, FunctionType resolvedFunctionType) { + // Conveniently, all value types we want to represent can fit inside a Java long. + // We store the typeIdx (of reference types) in the upper 4 bytes and the opcode in the + // lower 4 bytes. + if (opcode == ID.FuncRef) { + typeIdx = TypeIdxCode.FUNC.code(); + opcode = ID.RefNull; + } else if (opcode == ID.ExternRef) { + typeIdx = TypeIdxCode.EXTERN.code(); + opcode = ID.RefNull; + } else if (opcode == ID.ExnRef) { + typeIdx = TypeIdxCode.EXN.code(); + opcode = ID.RefNull; + } else if ((opcode == ID.RefNull || opcode == ID.Ref) && typeIdx >= 0) { + Objects.requireNonNull(resolvedFunctionType); + } + this.resolvedFunctionType = resolvedFunctionType; + + this.id = createId(opcode, typeIdx); + } + + private static long createId(int opcode, int typeIdx) { + return ((long) typeIdx) << TYPEIDX_SHIFT | (opcode & OPCODE_MASK); + } + + /** + * @return id of this ValType + */ + public long id() { + return this.id; + } + + private static int opcode(long id) { + return (int) (id & OPCODE_MASK); + } + + public int opcode() { + return opcode(id); + } + + private static int typeIdx(long id) { + return (int) (id >>> TYPEIDX_SHIFT); + } + + public int typeIdx() { + return typeIdx(id); + } + + /** + * @return the size of this type in memory + * @throws IllegalStateException if the type cannot be stored in memory + */ + public int size() { + switch (this.opcode()) { + case ID.F64: + case ID.I64: + return 8; + case ID.F32: + case ID.I32: + return 4; + case ID.V128: + return 16; + default: + throw new IllegalStateException("Type does not have size"); + } + } + + /** + * @return {@code true} if the type is a numeric type, or {@code false} otherwise + */ + public boolean isNumeric() { + switch (this.opcode()) { + case ID.F64: + case ID.F32: + case ID.I64: + case ID.I32: + return true; + default: + return false; + } + } + + /** + * @return {@code true} if the type is an integer type, or {@code false} otherwise + */ + public boolean isInteger() { + switch (this.opcode()) { + case ID.I64: + case ID.I32: + return true; + default: + return false; + } + } + + /** + * @return {@code true} if the type is a floating-point type, or {@code false} otherwise + */ + public boolean isFloatingPoint() { + switch (this.opcode()) { + case ID.F64: + case ID.F32: + return true; + default: + return false; + } + } + + /** + * @return {@code true} if the type is a reference type, or {@code false} otherwise + */ + private static boolean isReference(int opcode) { + switch (opcode) { + case ID.Ref: + case ID.ExnRef: + case ID.RefNull: + return true; + default: + return false; + } + } + + public boolean isReference() { + return isReference(this.opcode()); + } + + /** + * @return {@code true} if the given type ID is a valid value type ID, or {@code false} if it is not + */ + private static boolean isValidOpcode(int opcode) { + switch (opcode) { + case ID.RefNull: + case ID.Ref: + case ID.ExnRef: + case ID.V128: + case ID.I32: + case ID.I64: + case ID.F32: + case ID.F64: + case ID.FuncRef: + case ID.ExternRef: + return true; + default: + return false; + } + } + + public static boolean isValid(long id) { + return isValidOpcode(opcode(id)); + } + + public static int sizeOf(List args) { + int total = 0; + for (var a : args) { + if (a.opcode() == ID.V128) { + total += 2; + } else { + total += 1; + } + } + return total; + } + + private static boolean matchesNull(boolean null1, boolean null2) { + return null1 == null2 || null2; + } + + public static boolean matchesRef(ValType t1, ValType t2) { + var matchesNull = matchesNull(t1.isNullable(), t2.isNullable()); + if (!matchesNull) { + return false; + } + + if (t1.typeIdx() >= 0 && t2.typeIdx() == TypeIdxCode.FUNC.code()) { + return true; + } else if (t1.typeIdx() >= 0 && t2.typeIdx() >= 0) { + return t1.resolvedFunctionType.equals(t2.resolvedFunctionType); + } else if (t1.typeIdx() == TypeIdxCode.BOT.code()) { + return true; + } + return t1.typeIdx() == t2.typeIdx(); + } + + public static boolean matches(ValType t1, ValType t2) { + if (t1.isReference() && t2.isReference()) { + return matchesRef(t1, t2); + } else if (t1.opcode() == ID.BOT) { + return true; + } else { + return t1.id() == t2.id(); + } + } + + public boolean isNullable() { + switch (opcode()) { + case ID.Ref: + return false; + case ID.RefNull: + return true; + default: + throw new IllegalArgumentException( + "got non-reference type to isNullable(): " + this); + } + } + + @Override + public int hashCode() { + if (this.resolvedFunctionType != null) { + return resolvedFunctionType.hashCode(); + } + return Long.hashCode(id); + } + + @Override + public boolean equals(Object other) { + if (!(other instanceof ValType)) { + return false; + } + ValType that = (ValType) other; + + if (this.resolvedFunctionType != null && that.resolvedFunctionType != null) { + return opcode(this.id) == opcode(that.id) + && this.resolvedFunctionType.equals(that.resolvedFunctionType); + } else if (this.resolvedFunctionType == null && that.resolvedFunctionType == null) { + return this.id == that.id; + } else { + return false; + } + } + + @Override + public String toString() { + switch (opcode()) { + case ID.Ref: + case ID.RefNull: + return ID.toName(opcode()) + "[" + typeIdx() + "]"; + default: + return ID.toName(opcode()); + } + } + + /** + * a string representation of [ValType] that follows JVM's naming conventions + */ + public String name() { + return ID.toName(opcode()); + } + + public enum TypeIdxCode { + // heap type + EXTERN(-17), // 0x6F + FUNC(-16), // 0x70 + EXN(-23), // 0x69 + BOT(-1); + + private final int code; + + TypeIdxCode(int code) { + this.code = code; + } + + public int code() { + return this.code; + } + } + + /** + * A separate holder class for ID constants. + * This is necessary because enum constants are initialized before normal fields, so any reference to an ID constant + * in the same class would be considered an invalid forward reference. + */ + public static final class ID { + private ID() {} + + public static final int BOT = -1; + public static final int RefNull = 0x63; + public static final int Ref = 0x64; + public static final int ExternRef = 0x6f; + // From the Exception Handling proposal + public static final int ExnRef = 0x69; // -0x17 + public static final int FuncRef = 0x70; + public static final int V128 = 0x7b; + public static final int F64 = 0x7c; + public static final int F32 = 0x7d; + public static final int I64 = 0x7e; + public static final int I32 = 0x7f; + + public static String toName(int opcode) { + switch (opcode) { + case BOT: + return "Bot"; + case RefNull: + return "RefNull"; + case Ref: + return "Ref"; + case ExnRef: + return "ExnRef"; + case V128: + return "V128"; + case F64: + return "F64"; + case F32: + return "F32"; + case I64: + return "I64"; + case I32: + return "I32"; + } + + throw new IllegalArgumentException("got invalid opcode in ValType.toName: " + opcode); + } + + public static boolean isValidOpcode(int opcode) { + return (opcode == RefNull + || opcode == Ref + || opcode == ExternRef + || opcode == FuncRef + || opcode == ExnRef + || opcode == V128 + || opcode == F64 + || opcode == F32 + || opcode == I64 + || opcode == I32); + } + } + + public static Builder builder() { + return new Builder(); + } + + public static final class Builder { + private int opcode; + private int typeIdx = NULL_TYPEIDX; + + private Builder() {} + + public Builder withOpcode(int opcode) { + this.opcode = opcode; + return this; + } + + public Builder withTypeIdx(int typeIdx) { + this.typeIdx = typeIdx; + return this; + } + + public Builder fromId(long id) { + this.opcode = opcode(id); + this.typeIdx = ValType.typeIdx(id); + return this; + } + + public long id() { + return createId(opcode, typeIdx); + } + + public int typeIdx() { + return typeIdx; + } + + public boolean isReference() { + return ValType.isReference(opcode); + } + + public ValType build() { + return build( + (i) -> { + throw new ChicoryException("build with empty context tried resolving " + i); + }); + } + + public ValType build(Function context) { + if (!isValidOpcode(opcode)) { + throw new ChicoryException("Invalid type opcode: " + opcode); + } + + var resolvedFunctionType = substitute(opcode, typeIdx, context); + return new ValType(opcode, typeIdx, resolvedFunctionType); + } + + public FunctionType substitute( + int opcode, int typeIdx, Function context) { + if (ValType.isReference(opcode) && typeIdx >= 0) { + // no need to recursively substitute because all ValType are fully resolved + try { + return context.apply(typeIdx); + } catch (IndexOutOfBoundsException e) { + throw new InvalidException("unknown type: " + typeIdx); + } + } + + return null; + } + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Value.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Value.java new file mode 100644 index 000000000..e9fe36e5f --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/Value.java @@ -0,0 +1,333 @@ +package com.dylibso.chicory.wasm.types; + +import static java.util.Objects.requireNonNull; + +import java.util.Objects; + +public class Value { + + public static final long TRUE = 1L; + public static final long FALSE = 0L; + public static final int REF_NULL_VALUE = -1; + public static final long[] EMPTY_VALUES = new long[0]; + + private final ValType type; + + private final long data; + + public long raw() { + return data; + } + + public ValType type() { + return type; + } + + public static long floatToLong(float data) { + return Float.floatToRawIntBits(data); + } + + public static float longToFloat(long data) { + return Float.intBitsToFloat((int) data); + } + + public static long doubleToLong(double data) { + return Double.doubleToRawLongBits(data); + } + + public static double longToDouble(long data) { + return Double.longBitsToDouble(data); + } + + public static Value fromFloat(float data) { + return Value.f32(floatToLong(data)); + } + + public int asInt() { + assert (type == ValType.I32); + return (int) data; + } + + public long asLong() { + assert (type == ValType.I64); + return data; + } + + public float asFloat() { + assert (type == ValType.F32); + return longToFloat(data); + } + + public double asDouble() { + assert (type == ValType.F64); + return longToDouble(data); + } + + public static Value fromDouble(double data) { + return Value.f64(doubleToLong(data)); + } + + public static Value i32(int data) { + return i32((long) data); + } + + public static Value i32(long data) { + return new Value(ValType.I32, data); + } + + public static Value i64(long data) { + return new Value(ValType.I64, data); + } + + public static Value f32(long data) { + return new Value(ValType.F32, data); + } + + public static Value f64(long data) { + return new Value(ValType.F64, data); + } + + public static Value externRef(long data) { + return new Value(ValType.ExternRef, data); + } + + public static Value funcRef(long data) { + return new Value(ValType.FuncRef, data); + } + + /** + * @deprecated use {@link #Value(ValType, long)} + */ + @Deprecated(since = "1.3.0") + public Value(ValueType type, long value) { + this.type = requireNonNull(type, "type").toValType(); + data = value; + } + + public Value(ValType type, long value) { + this.type = requireNonNull(type, "type"); + data = value; + } + + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public static byte[] vecTo8(long[] values) { + var result = new byte[values.length * 8]; + var valueIdx = 0; + for (int i = 0; i < result.length; i++) { + var v = values[valueIdx++]; + result[i] = (byte) (v & 0xFFL); + result[++i] = (byte) ((v >> 8) & 0xFFL); + result[++i] = (byte) ((v >> 16) & 0xFFL); + result[++i] = (byte) ((v >> 24) & 0xFFL); + result[++i] = (byte) ((v >> 32) & 0xFFL); + result[++i] = (byte) ((v >> 40) & 0xFFL); + result[++i] = (byte) ((v >> 48) & 0xFFL); + result[++i] = (byte) ((v >> 56) & 0xFFL); + } + return result; + } + + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public static long[] bytesToVec(byte[] bytes) { + var result = new long[bytes.length / 8]; + var valueIdx = 0; + for (int i = 0; i < bytes.length; i++) { + result[valueIdx++] = + Byte.toUnsignedLong(bytes[i]) + (Byte.toUnsignedLong(bytes[++i]) << 8L) + | (Byte.toUnsignedLong(bytes[++i]) << 16L) + | (Byte.toUnsignedLong(bytes[++i]) << 24L) + | (Byte.toUnsignedLong(bytes[++i]) << 32L) + | (Byte.toUnsignedLong(bytes[++i]) << 40L) + | (Byte.toUnsignedLong(bytes[++i]) << 48L) + | (Byte.toUnsignedLong(bytes[++i]) << 56L); + } + return result; + } + + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public static int[] vecTo16(long[] values) { + var result = new int[values.length * 4]; + var valueIdx = 0; + for (int i = 0; i < result.length; i++) { + var v = values[valueIdx++]; + result[i] = (int) (v & 0xFFFFL); + result[++i] = (int) ((v >> 16) & 0xFFFFL); + result[++i] = (int) ((v >> 32) & 0xFFFFL); + result[++i] = (int) ((v >> 48) & 0xFFFFL); + } + return result; + } + + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public static long[] vecTo32(long[] values) { + var result = new long[values.length * 2]; + var valueIdx = 0; + for (int i = 0; i < result.length; i++) { + var v = values[valueIdx++]; + result[i] = (v & 0xFFFFFFFFL); + result[++i] = ((v >> 32) & 0xFFFFFFFFL); + } + return result; + } + + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public static float[] vecToF32(long[] values) { + var result = new float[values.length * 2]; + var valueIdx = 0; + for (int i = 0; i < result.length; i++) { + var v = values[valueIdx++]; + result[i] = Float.intBitsToFloat((int) (v & 0xFFFFFFFFL)); + result[++i] = Float.intBitsToFloat((int) ((v >> 32) & 0xFFFFFFFFL)); + } + return result; + } + + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public static double[] vecToF64(long[] values) { + var result = new double[values.length]; + for (int i = 0; i < result.length; i++) { + result[i] = Double.longBitsToDouble(values[i]); + } + return result; + } + + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public static long[] i8ToVec(long[]... vec) { + var result = new long[vec.length * 2]; + for (int i = 0; i < result.length; ) { + long[] v = vec[i]; + result[i++] = + (v[0] & 0xFF) + | ((v[1] & 0xFF) << 8) + | ((v[2] & 0xFF) << 16) + | ((v[3] & 0xFF) << 24) + | ((v[4] & 0xFF) << 32) + | ((v[5] & 0xFF) << 40) + | ((v[6] & 0xFF) << 48) + | ((v[7] & 0xFF) << 56); + result[i++] = + (v[8] & 0xFF) + | ((v[9] & 0xFF) << 8) + | ((v[10] & 0xFF) << 16) + | ((v[11] & 0xFF) << 24) + | ((v[12] & 0xFF) << 32) + | ((v[13] & 0xFF) << 40) + | ((v[14] & 0xFF) << 48) + | ((v[15] & 0xFF) << 56); + } + return result; + } + + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public static long[] i16ToVec(long[]... vec) { + var result = new long[vec.length * 2]; + for (int i = 0; i < result.length; ) { + long[] v = vec[i]; + result[i++] = + (v[0] & 0xFFFF) + | ((v[1] & 0xFFFF) << 16) + | ((v[2] & 0xFFFF) << 32) + | ((v[3] & 0xFFFF) << 48); + result[i++] = + (v[4] & 0xFFFF) + | ((v[5] & 0xFFFF) << 16) + | ((v[6] & 0xFFFF) << 32) + | ((v[7] & 0xFFFF) << 48); + } + return result; + } + + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public static long[] i32ToVec(long[]... vec) { + var result = new long[vec.length * 2]; + for (int i = 0; i < result.length; ) { + long[] v = vec[i]; + result[i++] = (v[1] & 0xFFFF_FFFFL) << 32 | (v[0] & 0xFFFF_FFFFL); + result[i++] = (v[3] & 0xFFFF_FFFFL) << 32 | (v[2] & 0xFFFF_FFFFL); + } + return result; + } + + // This is really only a convenience method to concat the vectors. + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public static long[] i64ToVec(long[]... vec) { + var result = new long[vec.length * 2]; + for (int i = 0; i < result.length; ) { + long[] v = vec[i]; + result[i++] = v[0]; + result[i++] = v[1]; + } + return result; + } + + // Since the longs are already converted, this is just a wrapper for i32ToVec + public static long[] f32ToVec(long[]... vec) { + return i32ToVec(vec); + } + + // Since the longs are already converted, this is just a wrapper for i64ToVec + public static long[] f64ToVec(long[]... vec) { + return i64ToVec(vec); + } + + /** + * Create a zeroed value for the particular type. + * + * @param valType must be a valid zeroable type. + * @return a zero. + */ + public static long zero(ValType valType) { + switch (valType.opcode()) { + case ValType.ID.I32: + case ValType.ID.F32: + case ValType.ID.I64: + case ValType.ID.F64: + return 0L; + case ValType.ID.ExnRef: + case ValType.ID.Ref: + case ValType.ID.RefNull: + return REF_NULL_VALUE; + default: + throw new IllegalArgumentException("Can't create a zero value for type " + valType); + } + } + + @Override + public String toString() { + switch (type.opcode()) { + case ValType.ID.I32: + return ((int) data) + "@i32"; + case ValType.ID.I64: + return data + "@i64"; + case ValType.ID.F32: + return longToFloat(data) + "@f32"; + case ValType.ID.F64: + return longToDouble(data) + "@f64"; + case ValType.ID.V128: + return data + "@v128"; + case ValType.ID.Ref: + return "ref[" + (int) data + "]"; + case ValType.ID.RefNull: + return "refnull[" + (int) data + "]"; + default: + throw new AssertionError("Unhandled type: " + type); + } + } + + @Override + public final boolean equals(Object v) { + if (v == this) { + return true; + } + if (!(v instanceof Value)) { + return false; + } + Value other = (Value) v; + return type.id() == other.type.id() && data == other.data; + } + + @Override + public final int hashCode() { + return Objects.hash(type.id(), data); + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ValueType.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ValueType.java new file mode 100644 index 000000000..f24d853db --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/ValueType.java @@ -0,0 +1,227 @@ +package com.dylibso.chicory.wasm.types; + +import com.dylibso.chicory.wasm.MalformedException; +import java.util.List; + +/** + * @deprecated use {@link com.dylibso.chicory.wasm.types.ValType} + */ +@Deprecated(since = "1.3.0") +public enum ValueType { + UNKNOWN(-1), + F64(ID.F64), + F32(ID.F32), + I64(ID.I64), + I32(ID.I32), + V128(ID.V128), + FuncRef(ID.FuncRef), + ExnRef(ID.ExnRef), + ExternRef(ID.ExternRef); + + private final int id; + + ValueType(int id) { + this.id = id; + } + + /** + * @return the numerical identifier for this type + */ + public int id() { + return id; + } + + /** + * @return the size of this type in memory + * + * @throws IllegalStateException if the type cannot be stored in memory + */ + public int size() { + switch (this) { + case F64: + case I64: + return 8; + case F32: + case I32: + return 4; + case V128: + return 16; + default: + throw new IllegalStateException("Type does not have size"); + } + } + + /** + * @return {@code true} if the type is a numeric type, or {@code false} otherwise + */ + public boolean isNumeric() { + switch (this) { + case F64: + case F32: + case I64: + case I32: + return true; + default: + return false; + } + } + + /** + * @return {@code true} if the type is an integer type, or {@code false} otherwise + */ + public boolean isInteger() { + switch (this) { + case I64: + case I32: + return true; + default: + return false; + } + } + + /** + * @return {@code true} if the type is a floating-point type, or {@code false} otherwise + */ + public boolean isFloatingPoint() { + switch (this) { + case F64: + case F32: + return true; + default: + return false; + } + } + + /** + * @return {@code true} if the type is a reference type, or {@code false} otherwise + */ + public boolean isReference() { + switch (this) { + case FuncRef: + case ExnRef: + case ExternRef: + return true; + default: + return false; + } + } + + /** + * @return {@code true} if the given type ID is a valid value type ID, or {@code false} if it is not + */ + public static boolean isValid(int typeId) { + switch (typeId) { + case ID.ExternRef: + case ID.ExnRef: + case ID.FuncRef: + case ID.V128: + case ID.I32: + case ID.I64: + case ID.F32: + case ID.F64: + return true; + default: + return false; + } + } + + /** + * @return the {@code ValueType} for the given ID value + * + * @throws IllegalArgumentException if the ID value does not correspond to a valid value type + */ + public static ValueType forId(int id) { + switch (id) { + case ID.F64: + return F64; + case ID.F32: + return F32; + case ID.I64: + return I64; + case ID.I32: + return I32; + case ID.V128: + return V128; + case ID.FuncRef: + return FuncRef; + case ID.ExnRef: + return ExnRef; + case ID.ExternRef: + return ExternRef; + default: + throw new IllegalArgumentException("Invalid value type " + id); + } + } + + public ValType toValType() { + switch (id) { + case ID.F64: + return ValType.F64; + case ID.F32: + return ValType.F32; + case ID.I64: + return ValType.I64; + case ID.I32: + return ValType.I32; + case ID.V128: + return ValType.V128; + case ID.FuncRef: + return ValType.FuncRef; + case ID.ExnRef: + return ValType.ExnRef; + case ID.ExternRef: + return ValType.ExternRef; + default: + throw new IllegalArgumentException("Invalid value type " + id); + } + } + + /** + * @return the reference-typed {@code ValueType} for the given ID value + * + * @throws IllegalArgumentException if the ID value does not correspond to a valid reference type + */ + public static ValueType refTypeForId(int id) { + switch (id) { + case ID.FuncRef: + return FuncRef; + case ID.ExternRef: + return ExternRef; + case ID.ExnRef: + return ExnRef; + default: + throw new MalformedException("malformed reference type " + id); + } + } + + public static int sizeOf(List args) { + int total = 0; + for (var a : args) { + if (a == ValueType.V128) { + total += 2; + } else { + total += 1; + } + } + return total; + } + + /** + * A separate holder class for ID constants. + * This is necessary because enum constants are initialized before normal fields, so any reference to an ID constant + * in the same class would be considered an invalid forward reference. + */ + static final class ID { + private ID() {} + + static final int ExternRef = 0x6f; + // From the Exception Handling proposal + static final int ExnRef = 0x69; // -0x17 + static final int FuncRef = 0x70; + static final int V128 = 0x7b; + static final int F64 = 0x7c; + static final int F32 = 0x7d; + static final int I64 = 0x7e; + static final int I32 = 0x7f; + } +} diff --git a/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/WasmEncoding.java b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/WasmEncoding.java new file mode 100644 index 000000000..8393ed7a6 --- /dev/null +++ b/decompiled-wabt/src/main/java/com/dylibso/chicory/wasm/types/WasmEncoding.java @@ -0,0 +1,15 @@ +package com.dylibso.chicory.wasm.types; + +public enum WasmEncoding { + VARUINT, + VARSINT32, + VARSINT64, + FLOAT32, + FLOAT64, + VEC_VARUINT, + VEC_CATCH, + BYTE, + V128, + BLOCK_TYPE, + VEC_VALUE_TYPE +} diff --git a/decompiled-wabt/src/main/resources/com/dylibso/chicory/wabt/Wat2WasmModule.meta b/decompiled-wabt/src/main/resources/com/dylibso/chicory/wabt/Wat2WasmModule.meta new file mode 100644 index 000000000..b97d4763f Binary files /dev/null and b/decompiled-wabt/src/main/resources/com/dylibso/chicory/wabt/Wat2WasmModule.meta differ diff --git a/decompiled-wabt/src/main/resources/wat2wasm b/decompiled-wabt/src/main/resources/wat2wasm new file mode 100755 index 000000000..dca123475 Binary files /dev/null and b/decompiled-wabt/src/main/resources/wat2wasm differ diff --git a/decompiled-wabt/src/test/java/com/dylibso/chicory/wabt/Wat2WasmTest.java b/decompiled-wabt/src/test/java/com/dylibso/chicory/wabt/Wat2WasmTest.java new file mode 100644 index 000000000..a09a67608 --- /dev/null +++ b/decompiled-wabt/src/test/java/com/dylibso/chicory/wabt/Wat2WasmTest.java @@ -0,0 +1,39 @@ +package com.dylibso.chicory.wabt; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.wasm.Parser; +import java.io.File; +import org.junit.jupiter.api.Test; + +public class Wat2WasmTest { + + @Test + public void shouldRunWat2Wasm() throws Exception { + var result = Wat2Wasm.parse(new File("../wasm-corpus/src/main/resources/wat/iterfact.wat")); + + assertTrue(result.length > 0); + assertTrue(new String(result, UTF_8).contains("iterFact")); + } + + @Test + public void shouldRunWat2WasmOnString() { + var moduleInstance = + Instance.builder( + Parser.parse( + Wat2Wasm.parse( + "(module (func (export \"add\") (param $x" + + " i32) (param $y i32) (result i32)" + + " (i32.add (local.get $x) (local.get" + + " $y))))"))) + .withInitialize(true) + .build(); + + var addFunction = moduleInstance.export("add"); + var results = addFunction.apply(1, 41); + assertEquals(42L, results[0]); + } +} diff --git a/pom.xml b/pom.xml index a0a00ee23..491ddd2d4 100644 --- a/pom.xml +++ b/pom.xml @@ -158,6 +158,11 @@ simd ${project.version} + + com.dylibso.chicory + source-compiler + ${project.version} + com.dylibso.chicory test-gen-lib @@ -967,6 +972,8 @@ machine-tests runtime runtime-tests + source-compiler + source-compiler-wasi-tests test-gen-lib test-gen-plugin wabt diff --git a/source-compiler-wasi-tests/pom.xml b/source-compiler-wasi-tests/pom.xml new file mode 100644 index 000000000..947ac22ff --- /dev/null +++ b/source-compiler-wasi-tests/pom.xml @@ -0,0 +1,120 @@ + + + 4.0.0 + + + com.dylibso.chicory + chicory + 999-SNAPSHOT + ../pom.xml + + source-compiler-wasi-tests + jar + + Chicory - Source Compiler WASI Tests + WASI Preview 1 tests using the source compiler machine factory + + + + com.dylibso.chicory + log + test + + + com.dylibso.chicory + runtime + test + + + com.dylibso.chicory + source-compiler + test + + + com.dylibso.chicory + wasi + test + + + com.dylibso.chicory + wasm + test + + + com.dylibso.chicory + wasm-corpus + test + + + io.roastedroot + zerofs + test + + + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine + test + + + + + + com.dylibso.chicory + wasi-test-gen-plugin + ${project.version} + + ${project.basedir}/../wasi-testsuite + + + tests/assemblyscript/testsuite/wasm32-wasip1/*.wasm + tests/c/testsuite/wasm32-wasip1/*.wasm + tests/rust/testsuite/wasm32-wasip1/*.wasm + + + + tests/rust/testsuite/wasm32-wasip1/fd_flags_set.wasm + + tests/c/testsuite/wasm32-wasip1/pwrite-with-append.wasm + + tests/rust/testsuite/wasm32-wasip1/dangling_symlink.wasm + + tests/rust/testsuite/wasm32-wasip1/symlink_filestat.wasm + + tests/rust/testsuite/wasm32-wasip1/fd_fdstat_set_rights.wasm + tests/rust/testsuite/wasm32-wasip1/truncation_rights.wasm + + + + + + + wasi-test-gen + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + + default-testCompile + + + --add-modules + java.sql + --add-modules + java.desktop + + + + + + + + diff --git a/source-compiler-wasi-tests/src/test/java/com/dylibso/chicory/wasi/MockPrintStream.java b/source-compiler-wasi-tests/src/test/java/com/dylibso/chicory/wasi/MockPrintStream.java new file mode 100644 index 000000000..877dad7c5 --- /dev/null +++ b/source-compiler-wasi-tests/src/test/java/com/dylibso/chicory/wasi/MockPrintStream.java @@ -0,0 +1,24 @@ +package com.dylibso.chicory.wasi; + +import static java.nio.charset.StandardCharsets.UTF_8; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +class MockPrintStream extends PrintStream { + private final ByteArrayOutputStream baos; + + public MockPrintStream() { + super(new ByteArrayOutputStream()); + this.baos = (ByteArrayOutputStream) this.out; + } + + @Override + public void println(String s) { + super.println(s); + } + + public String output() { + return baos.toString(UTF_8); + } +} diff --git a/source-compiler-wasi-tests/src/test/java/com/dylibso/chicory/wasi/WasiTestRunner.java b/source-compiler-wasi-tests/src/test/java/com/dylibso/chicory/wasi/WasiTestRunner.java new file mode 100644 index 000000000..e523c7820 --- /dev/null +++ b/source-compiler-wasi-tests/src/test/java/com/dylibso/chicory/wasi/WasiTestRunner.java @@ -0,0 +1,109 @@ +package com.dylibso.chicory.wasi; + +import static com.dylibso.chicory.wasi.Files.copyDirectory; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.dylibso.chicory.log.SystemLogger; +import com.dylibso.chicory.runtime.ImportValues; +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.source.compiler.MachineFactorySourceCompiler; +import com.dylibso.chicory.wasm.Parser; +import io.roastedroot.zerofs.Configuration; +import io.roastedroot.zerofs.ZeroFs; +import java.io.File; +import java.io.IOException; +import java.io.UncheckedIOException; +import java.nio.file.FileSystem; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +public final class WasiTestRunner { + private static final SystemLogger LOGGER = new SystemLogger(); + + private WasiTestRunner() {} + + public static void execute( + File test, + List args, + List dirs, + Map env, + int exitCode, + Optional stdout) { + + try (FileSystem fs = + ZeroFs.newFileSystem( + Configuration.unix().toBuilder().setAttributeViews("unix").build())) { + + var stdoutStream = new MockPrintStream(); + var stderrStream = new MockPrintStream(); + + List allArgs = new ArrayList<>(); + allArgs.add("test"); + allArgs.addAll(args); + + WasiOptions.Builder options = + WasiOptions.builder() + .withStdout(stdoutStream) + .withStderr(stderrStream) + .withArguments(allArgs); + + env.forEach(options::withEnvironment); + // TODO: dangling filesystem is not supported + if (!test.getName().contains("environ")) { + options.withEnvironment("NO_DANGLING_FILESYSTEM", "true"); + } + + for (String dir : dirs) { + Path source = test.getParentFile().toPath().resolve(dir); + Path target = fs.getPath(dir); + copyDirectory(source, target); + options.withDirectory(target.toString(), target); + } + + int actualExitCode; + try { + actualExitCode = execute(test, options.build()); + } catch (WasiExitException e) { + actualExitCode = e.exitCode(); + } catch (RuntimeException e) { + String message = "Failed to execute test: " + test; + if (!stdoutStream.output().isEmpty() || !stderrStream.output().isEmpty()) { + message += "\n<<<<<\n"; + message += (stdoutStream.output() + stderrStream.output()).strip(); + message += "\n>>>>>"; + } + throw new RuntimeException(message, e); + } + + assertEquals(exitCode, actualExitCode, "exit code"); + stdout.ifPresent(expected -> assertEquals(expected, stdoutStream.output(), "stdout")); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + } + + private static int execute(File test, WasiOptions wasiOptions) { + try (var wasi = + WasiPreview1.builder().withLogger(LOGGER).withOptions(wasiOptions).build()) { + var module = Parser.parse(test); + Instance.builder(module) + .withImportValues( + ImportValues.builder().addFunction(wasi.toHostFunctions()).build()) + .withMachineFactory( + instance -> + MachineFactorySourceCompiler.builder(instance.module()) + .withClassName( + "com.dylibso.chicory.gen.WasiTestMachine") + .withDumpSources(true) + .compile() + .apply(instance)) + .build(); + } catch (WasiExitException e) { + return e.exitCode(); + } + return 0; + } +} diff --git a/source-compiler-wasi-tests/src/test/resources/logging.properties b/source-compiler-wasi-tests/src/test/resources/logging.properties new file mode 100644 index 000000000..ed9f63e93 --- /dev/null +++ b/source-compiler-wasi-tests/src/test/resources/logging.properties @@ -0,0 +1,54 @@ +############################################################ +# Default Logging Configuration File +# +# You can use a different file by specifying a filename +# with the java.util.logging.config.file system property. +# For example java -Djava.util.logging.config.file=myfile +############################################################ + +############################################################ +# Global properties +############################################################ + +# "handlers" specifies a comma separated list of log Handler +# classes. These handlers will be installed during VM startup. +# Note that these classes must be on the system classpath. +# By default we only configure a ConsoleHandler, which will only +# show messages at the INFO and above levels. +handlers= java.util.logging.ConsoleHandler + +# To also add the FileHandler, use the following line instead. +#handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler + +# Default global logging level. +# This specifies which kinds of events are logged across +# all loggers. For any given facility this global level +# can be overriden by a facility specific level +# Note that the ConsoleHandler also has a separate level +# setting to limit messages printed to the console. +.level= ALL + +############################################################ +# Handler specific properties. +# Describes specific configuration info for Handlers. +############################################################ + +# default file output is in user's home directory. +#java.util.logging.FileHandler.pattern = %h/java%u.log +#java.util.logging.FileHandler.limit = 50000 +#java.util.logging.FileHandler.count = 1 +#java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter + +# Limit the message that are printed on the console to INFO and above. +java.util.logging.ConsoleHandler.level = WARNING +java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter + + +############################################################ +# Facility specific properties. +# Provides extra control for each logger. +############################################################ + +# For example, set the com.xyz.foo logger to only log SEVERE +# messages: +#com.xyz.foo.level = SEVERE diff --git a/source-compiler/PORTING_NOTES.md b/source-compiler/PORTING_NOTES.md new file mode 100644 index 000000000..8cb1ee421 --- /dev/null +++ b/source-compiler/PORTING_NOTES.md @@ -0,0 +1,281 @@ +## Source compiler porting notes + +### Goal + +- **End goal**: make the **source compiler** feature-complete with the existing ASM-based compiler so that we can eventually compile *all* spec tests (and `wat2wasm`) to **Java source** instead of bytecode. +- **Strategy**: port the behavior of the old compiler **1:1** into `SourceCodeEmitter`, either: + - **Inlining** the same primitive operations the ASM compiler emits, or + - **Delegating** to `com.dylibso.chicory.runtime.OpcodeImpl` when the ASM compiler uses `.shared(...)` in `EmitterMap`. + +### Where things live + +- **Old ASM compiler (reference behavior)**: + - Opcodes enum: `compiler/src/main/java/com/dylibso/chicory/compiler/internal/CompilerOpCode.java` + - ASM emitters: `compiler/src/main/java/com/dylibso/chicory/compiler/internal/Emitters.java` + - Opcode mapping: `compiler/src/main/java/com/dylibso/chicory/compiler/internal/EmitterMap.java` + - Type analysis: `compiler/src/main/java/com/dylibso/chicory/compiler/internal/WasmAnalyzer.java` +- **New source compiler**: + - Main entry: `source-compiler/src/main/java/com/dylibso/chicory/source/compiler/MachineFactorySourceCompiler.java` + - Java AST emission: `source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SourceCodeEmitter.java` + - WasmAnalyzer (structured control flow): `source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/WasmAnalyzer.java` + - Compiler opcodes: `source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerOpCode.java` + - Test module & source dumping: `source-compiler/src/test/java/com/dylibso/chicory/testing/TestModule.java` + - Generated sources: `source-compiler/target/source-dump/com/dylibso/chicory/gen/...` + - Test generation config: `source-compiler/pom.xml` (`test-gen-plugin` section). + +### Porting principles (1:1 with ASM) + +- **For each opcode in `CompilerOpCode`**: + - Look up its mapping in `EmitterMap`: + - **`.intrinsic(CompilerOpCode.X, Emitters::X)`**: + - Reproduce the same logic **inline** in `SourceCodeEmitter` using JavaParser AST nodes. + - Example: `I32_WRAP_I64` is `L2I` in ASM → in source compiler: + - Pop a `long` expression and push `new CastExpr(PrimitiveType.intType(), value)`. + - **`.shared(CompilerOpCode.X, OpcodeImpl.class)`**: + - Call the matching static method on `OpcodeImpl` using `opcodeImplCall("X", args...)`. + - Add a `case` for the opcode in `SourceCodeEmitter.emitInstruction` that dispatches to the helper. +- **Stack discipline**: + - Mirror ASM evaluation order: **pop right operand first**, left second, then build expressions in `(a op b)` order. + - Keep the Java expression stack (`Deque`) consistent with `WasmAnalyzer`'s type stack. + +### Control flow design + +The source compiler uses **structured Java control flow** that mirrors WASM's structured control flow directly: + +- **WasmAnalyzer** walks WASM instructions and emits structured `CompilerOpCode`s: + - `BLOCK_ENTER` / `LOOP_ENTER` / `IF_ENTER` / `ELSE_ENTER` / `SCOPE_EXIT` — scope boundaries + - `BREAK` / `BREAK_IF` — forward branches (`br` targeting `block`/`if`) + - `CONTINUE` / `CONTINUE_IF` — backward branches (`br` targeting `loop`) + - `DROP_KEEP` — stack unwinding for branches that cross scope boundaries +- **SourceCodeEmitter** maps these to Java: + - `BLOCK_ENTER` → `label_N: { ... }` + - `LOOP_ENTER` → `label_N: while(true) { ... }` + - `IF_ENTER` → `label_N: { if (cond != 0) { ... } }` (wrapped in labeled block) + - `ELSE_ENTER` → `} else { ... }` + - `SCOPE_EXIT` → close block, assign results, push result vars to expression stack + - `BREAK` → assign results + `break label_N;` + - `BREAK_IF` → peek at stack values (no modification), emit `if (cond != 0) { assign results; break label_N; }`. Fall-through path keeps stack unchanged. + - `CONTINUE` → assign loop params + interrupt check + `continue label_N;` + - `CONTINUE_IF` → peek at stack values (reversed order), emit `if (cond != 0) { assign params with temps; continue label_N; }`. Fall-through path keeps stack unchanged. +- **Block results**: blocks with return types declare result variables at the method body level (so they're accessible regardless of nesting depth). Result values are assigned on break/exit and pushed onto the expression stack after SCOPE_EXIT. +- **If blocks**: wrapped in `LabeledStmt` + `BlockStmt` (like BLOCK_ENTER) so `break label_N` works. If-param variables declared with default values at function level, assigned inline. For if-without-else with params, an else branch is synthesized to pass params through to results. +- **Loop param assignment**: uses `assignParamsWithTemps` — single param: direct assign; multiple params: uses temp variables to avoid the "swap problem" where sequential assignments read already-modified values. +- **Conditional branches (BREAK_IF / CONTINUE_IF)**: use a **peek-based approach** — read values from the expression stack via `stack.iterator()` without popping. The iterator returns top-to-bottom, so for loop params the order is reversed (`paramVals[paramCount - 1 - i]`). The stack is left unchanged for the fall-through path. +- **Dead code tracking**: the analyzer uses `exitBlockDepth` + `exitTargetLabel` to skip instructions after unconditional branches. `exitTargetLabel` tracks which scope the dead code should stop at, handling `br N` where N > 0. For BLOCK/LOOP scopes, dead code mode is cleared on END (alternate paths via br_if make code after the block reachable). +- **Terminal detection for if/else**: an if/else is terminal for its parent only if BOTH branches terminate AND no break targets the if's own label. An if-without-else is never terminal. +- **Implicit return**: added at end of `generateFunctionMethod` for functions whose body doesn't end with return/throw but has stack values on the expression stack. +- **Function calls**: `instance.getMachine().call(funcId, args)` with boxing/unboxing via `SourceCompilerUtil.boxJvmToLong`/`unboxLongToJvm`. CALL and CALL_INDIRECT share a common `emitCallWithArgs` helper. CALL_INDIRECT resolves the `refInstance` from the table entry (`table.instance(idx)`) for cross-module dispatch — the function is called through `refInstance.getMachine().call()`, not the current module's machine. + +### Key implementation details + +- **`isBlockTerminated`**: checks if the current block's last statement is a direct terminal (throw/return/break/continue) or a labeled block that is terminal for the parent scope. A labeled block is terminal only if it ends with abrupt completion (throw/return/break/continue) AND no break targets its own label (which would mean flow continues after it). +- **SCOPE_EXIT result push**: only pushes result variables when the scope isn't terminal for the parent, preventing phantom stack values from dead inner blocks. +- **Operator precedence**: all `BinaryExpr` results are wrapped in `EnclosedExpr` (parentheses) to prevent precedence errors in compound expressions. +- **Float/double constants**: `NaN` and `Infinity` values are emitted as `Float.intBitsToFloat(bits)` / `Double.longBitsToDouble(bits)` / `Float.POSITIVE_INFINITY` etc., not via `toString()` which produces invalid Java literals. +- **Globals**: `GLOBAL_GET`/`GLOBAL_SET` use `instance.global(idx).getValue()`/`.setValue()` with proper type boxing/unboxing via `globalTypes`. + +### Memory and traps + +- **Memory access helpers** in `SourceCodeEmitter`: + - `getAddrExpr(base, offset)` matches the ASM pattern: + - `(base < 0) ? base : base + offset` + - `emitOutOfBoundsIfNeeded(offset, block)`: + - If compile-time offset is `< 0` or `>= Integer.MAX_VALUE`, emits: + - `throw new WasmRuntimeException("out of bounds memory access");` + - and returns early from the emitter method. + - This matches the ASM compiler's static offset trap behavior. +- **MEMORY_GROW** → `memory.grow(size)`, **MEMORY_SIZE** → `memory.pages()`. + +### Naming and packages + +- **Generated class names**: + - Pattern: `com.dylibso.chicory.gen..CompiledMachine_spec_`. + - `TestModule.extractMangledClassName` is the single place that constructs them. +- **Reserved words**: + - If a module directory name is a Java keyword (e.g. `const`), we suffix it with `_` (e.g. `const_`) when building the package path. + +### Current status + +**Test results (26,907 tests, 0 failures, 0 errors, 38 skipped):** + +All spec tests pass plus 25 ported WasmModuleTest tests. The full WASM v1 spec test suite is included and passing: + +| Test Suite | Pass/Total | Skipped | Notes | +|---|---|---|---| +| SpecV1AddressTest | 232/260 | 28 | skipped (trap behavior) | +| SpecV1AlignTest | 162/162 | 0 | | +| SpecV1BlockTest | 223/223 | 0 | | +| SpecV1BrTest | 97/97 | 0 | | +| SpecV1BrIfTest | 118/118 | 0 | | +| SpecV1BrTableTest | 174/174 | 0 | | +| SpecV1BulkTest | 117/117 | 0 | | +| SpecV1CallTest | 91/91 | 0 | | +| SpecV1CallIndirectTest | 172/172 | 0 | | +| SpecV1ConstTest | 778/778 | 0 | | +| SpecV1ConversionsTest | 619/619 | 0 | | +| SpecV1DataTest | 61/61 | 0 | | +| SpecV1ElemTest | 98/98 | 0 | cross-module CALL_INDIRECT fixed | +| SpecV1EndiannessTest | 69/69 | 0 | | +| SpecV1ExportsTest | 96/96 | 0 | | +| SpecV1F32Test | 2514/2514 | 0 | | +| SpecV1F32BitwiseTest | 364/364 | 0 | | +| SpecV1F32CmpTest | 2407/2407 | 0 | | +| SpecV1F64Test | 2514/2514 | 0 | | +| SpecV1F64BitwiseTest | 364/364 | 0 | | +| SpecV1F64CmpTest | 2407/2407 | 0 | | +| SpecV1FacTest | 8/8 | 0 | | +| SpecV1FloatExprsTest | 927/927 | 0 | | +| SpecV1FloatLiteralsTest | 179/179 | 0 | | +| SpecV1FloatMemoryTest | 90/90 | 0 | | +| SpecV1FloatMiscTest | 471/471 | 0 | | +| SpecV1ForwardTest | 5/5 | 0 | | +| SpecV1FuncTest | 172/172 | 0 | | +| SpecV1FuncPtrsTest | 36/36 | 0 | | +| SpecV1GlobalTest | 110/110 | 0 | | +| SpecV1I32Test | 460/460 | 0 | | +| SpecV1I64Test | 416/416 | 0 | | +| SpecV1IfTest | 241/241 | 0 | | +| SpecV1ImportsTest | 178/178 | 0 | | +| SpecV1IntExprsTest | 108/108 | 0 | | +| SpecV1IntLiteralsTest | 51/51 | 0 | | +| SpecV1LabelsTest | 29/29 | 0 | | +| SpecV1LeftToRightTest | 96/96 | 0 | | +| SpecV1LinkingTest | 132/132 | 0 | all passing (TrapException + cross-module fix) | +| SpecV1LoadTest | 97/97 | 0 | | +| SpecV1LocalGetTest | 36/36 | 0 | | +| SpecV1LocalSetTest | 53/53 | 0 | | +| SpecV1LocalTeeTest | 97/97 | 0 | | +| SpecV1LoopTest | 120/120 | 0 | | +| SpecV1MemoryCopyTest | 4450/4450 | 0 | | +| SpecV1MemoryFillTest | 100/100 | 0 | | +| SpecV1MemoryGrowTest | 104/104 | 0 | | +| SpecV1MemoryInitTest | 240/240 | 0 | | +| SpecV1MemoryRedundancyTest | 8/8 | 0 | | +| SpecV1MemorySizeTest | 42/42 | 0 | | +| SpecV1MemoryTest | 88/88 | 0 | | +| SpecV1MemoryTrapTest | 182/182 | 0 | | +| SpecV1NamesTest | 486/486 | 0 | | +| SpecV1NopTest | 88/88 | 0 | | +| SpecV1RefFuncTest | 17/17 | 0 | | +| SpecV1RefIsNullTest | 16/16 | 0 | | +| SpecV1RefNullTest | 3/3 | 0 | | +| SpecV1ReturnTest | 84/84 | 0 | | +| SpecV1SelectTest | 148/148 | 0 | | +| SpecV1SkipStackGuardPageTest | 11/11 | 0 | | +| SpecV1StackTest | 7/7 | 0 | | +| SpecV1StartTest | 20/20 | 0 | TrapException fix | +| SpecV1StoreTest | 68/68 | 0 | | +| SpecV1SwitchTest | 28/28 | 0 | | +| SpecV1TableCopyTest | 1728/1728 | 0 | | +| SpecV1TableFillTest | 45/45 | 0 | | +| SpecV1TableGetTest | 16/16 | 0 | | +| SpecV1TableGrowTest | 58/58 | 0 | | +| SpecV1TableInitTest | 780/780 | 0 | | +| SpecV1TableSetTest | 26/26 | 0 | | +| SpecV1TableSizeTest | 39/39 | 0 | | +| SpecV1TableSubTest | 2/2 | 0 | | +| SpecV1TableTest | 19/19 | 0 | | +| SpecV1TrapsTest | 26/36 | 10 | | +| SpecV1TypeTest | 3/3 | 0 | | +| SpecV1UnreachableTest | 64/64 | 0 | | +| SpecV1UnreachedValidTest | 7/7 | 0 | | +| SpecV1UnwindTest | 50/50 | 0 | | +| SourceCompilerTest | 3/3 | 0 | includes wat2wasm end-to-end | +| WasmModuleSourceCompilerTest | 25/25 | 0 | ported from runtime WasmModuleTest | + +**End-to-end wat2wasm compilation**: the source compiler successfully generates Java source from the wat2wasm binary (1,885 functions, ~12.7MB of source), javac compiles it to bytecode, and the compiled class loads and creates a machine factory. + +### Method splitting (`MethodSplitter`) + +The Java compiler enforces a 64KB bytecode limit per method. The `MethodSplitter` class (in `source-compiler/src/main/java/.../internal/MethodSplitter.java`) automatically handles this during source generation. + +**How it works:** + +1. **Local-to-array conversion**: converts `int var0`, `long var1`, etc. to `int[] iL`, `long[] lL` arrays so state can be shared between the original method and extracted helpers. + +2. **Block extraction**: finds the best labeled block to extract into a helper method. The block is replaced with a helper call + dispatch code: + ```java + // Original: label_5: { ... large code with break label_3; ... } + // After extraction: + label_5: { + int _d0 = func_804__h0(iL, lL, memory, instance); + if (_d0 == 1) break label_3; + if (_d0 == 2) return iL[0]; + } + ``` + +3. **Helper method pattern**: extracted code is wrapped in a `do-while(false)` pattern: + ```java + private static int func_804__h0(int[] iL, long[] lL, Memory memory, Instance instance) { + int[] _hs = { 0 }; + _hb: do { + // ... extracted code ... + // break label_3 becomes: { _hs[0] = 1; break _hb; } + // return X becomes: { iL[0] = X; _hs[0] = 2; break _hb; } + } while (false); + return _hs[0]; + } + ``` + +4. **Switch splitting**: for methods with large `switch` statements (br_table dispatch), the switch entries are split in half into two helper methods. + +**Key design decisions:** + +- **Block selection uses half-method targeting**: extracts the block closest to half the method size, not the absolute largest. This ensures geometric convergence (each split roughly halves the method). Extracting the largest block (which is often 90%+ of the method) just moves code without reducing it, causing divergent infinite loops. +- **75% cap**: blocks larger than 75% of the method are rejected for extraction to prevent the shift-without-reduce problem. +- **100-iteration safety cap**: prevents infinite loops if heuristics fail to converge. +- **Undeclared array detection**: `long[]` temporaries (e.g., `callArgs_0`, `callResult_1`) used in extracted blocks but declared at the parent method scope are re-declared inside the helper. +- **Switch helper status propagation**: the `_hs[0] = _sw; break _hb;` fallthrough for propagating status codes from switch helpers is only emitted when the parent method has the `_hb` do-while wrapper (i.e., it's itself a helper). Original methods don't have this wrapper, and all label codes are explicitly dispatched. + +### Known limitations and remaining work + +- **Sequential code splitting**: the `MethodSplitter` can only extract labeled blocks and split switch statements. Methods with large amounts of sequential code (no labeled blocks or switches) remain unsplit. These methods still compile via javac but may approach the 64KB limit for very large WASM functions. A future improvement would be to split sequential statement runs into helper methods. +- **Runtime correctness of wat2wasm**: the source compiler generates compilable code for wat2wasm, but running it produces "out of bounds memory access: attempted to access address: 67108872 but limit is: 786432" during instance initialization. The same error occurs with the hand-decompiled version, suggesting a pre-existing issue in the decompiled-wabt module (possibly stale runtime classes or a missing memory growth path). + +### Workflow for future porting sessions + +- **1. Add wast files from `excludedWasts` to `includedWasts`** + - Move a batch from excluded to included in `source-compiler/pom.xml`. + - Keep the lists alphabetically sorted (the plugin enforces this). + - Run: `mvn test-compile -f source-compiler/pom.xml -Dcheckstyle.skip=true` + +- **2. Run focused tests to discover missing opcodes** + - Example: + - `mvn test -f source-compiler/pom.xml -Dcheckstyle.skip=true -Dtest=SpecV1FloatMiscTest` + - Use a timeout to catch infinite loops: + - `timeout 60 mvn test -f source-compiler/pom.xml -Dcheckstyle.skip=true -Dtest=SpecV1FloatExprsTest` + - Look at errors like: + - `IllegalArgumentException: Unsupported opcode: XYZ` in generated `CompiledMachine_spec_*.java` under `source-compiler/target/source-dump/...`. + - `NoSuchElementException` = stack underflow (expression stack has fewer values than expected). + - `ClassNotFoundException` = source generation failed entirely (check the source-dump file for the error comment). + +- **3. Port the opcode 1:1** + - Find entry in `EmitterMap` for `CompilerOpCode.X`. + - If intrinsic: + - Open `Emitters.X` and copy behavior into a new `public static void X(...)` helper in `SourceCodeEmitter`, using JavaParser AST. + - If shared: + - Add a helper that calls `opcodeImplCall("X", args...)`. + - Wire a new `case X:` in `emitInstruction` to that helper. + - **Check for duplicates** — some opcodes may already have method implementations but are missing the switch case (or vice versa). + +- **4. Re-run the focused tests** + - Ensure: + - Generated source exists under `target/source-dump/...`. + - The specific spec test passes (at least on the **happy path**, even if trap/error messages differ slightly). + - If a test causes infinite loop, move it back to `excludedWasts` and note it in "Known issues" above. + +- **5. Compare with ASM compiler output** + - Compile the wasm with the ASM compiler: `/home/andreatp/workspace/chicory7/build-time-compiler-cli/target/chicory-compiler ` + - Decompile with javap: `javap -c -p ` + - Compare the JVM bytecode behavior with the generated Java source to debug discrepancies. + +### Long-term objective + +- Once all opcodes used by the spec tests are ported and the source compiler passes the same suite as the ASM compiler, we can: + - Switch decompilation / `wat2wasm` style tooling to use **source generation**. + - Remove reliance on the non-working decompilers and treat this source compiler as the canonical backend. + +Keep using the ASM compiler (`Emitters` + `EmitterMap`) as the **ground truth**. For each new opcode or behavior: + +- **Ask**: is it `.intrinsic(...)` (inline logic) or `.shared(..., OpcodeImpl.class)`? +- **Replicate** that choice in `SourceCodeEmitter`, maintaining stack order and side effects exactly 1:1. diff --git a/source-compiler/pom.xml b/source-compiler/pom.xml new file mode 100644 index 000000000..a8e29c55a --- /dev/null +++ b/source-compiler/pom.xml @@ -0,0 +1,310 @@ + + + 4.0.0 + + + com.dylibso.chicory + chicory + 999-SNAPSHOT + ../pom.xml + + source-compiler + jar + + Chicory - Compiler + Wasm to Java sources compiler + + + + com.dylibso.chicory + runtime + + + com.dylibso.chicory + wasm + + + + + com.github.javaparser + javaparser-core + + + com.dylibso.chicory + compiler + test + + + com.dylibso.chicory + wabt + test + + + com.dylibso.chicory + wasm-corpus + test + + + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine + test + + + + + + com.dylibso.chicory + test-gen-plugin + ${project.version} + + + address.wast + align.wast + block.wast + br.wast + br_if.wast + br_table.wast + bulk.wast + call.wast + call_indirect.wast + const.wast + conversions.wast + data.wast + elem.wast + endianness.wast + exports.wast + f32.wast + f32_bitwise.wast + f32_cmp.wast + f64.wast + f64_bitwise.wast + f64_cmp.wast + fac.wast + float_exprs.wast + float_literals.wast + float_memory.wast + float_misc.wast + forward.wast + func.wast + func_ptrs.wast + global.wast + i32.wast + i64.wast + if.wast + imports.wast + int_exprs.wast + int_literals.wast + labels.wast + left-to-right.wast + linking.wast + load.wast + local_get.wast + local_set.wast + local_tee.wast + loop.wast + memory.wast + memory_copy.wast + memory_fill.wast + memory_grow.wast + memory_init.wast + memory_redundancy.wast + memory_size.wast + memory_trap.wast + names.wast + nop.wast + ref_func.wast + ref_is_null.wast + ref_null.wast + return.wast + select.wast + skip-stack-guard-page.wast + stack.wast + start.wast + store.wast + switch.wast + table-sub.wast + table.wast + table_copy.wast + table_fill.wast + table_get.wast + table_grow.wast + table_init.wast + table_set.wast + table_size.wast + traps.wast + type.wast + unreachable.wast + unreached-valid.wast + unwind.wast + + + binary-leb128.wast + binary.wast + comments.wast + custom.wast + inline-module.wast + obsolete-keywords.wast + simd_address.wast + simd_align.wast + simd_bit_shift.wast + simd_bitwise.wast + simd_boolean.wast + simd_const.wast + simd_conversions.wast + simd_f32x4.wast + simd_f32x4_arith.wast + simd_f32x4_cmp.wast + simd_f32x4_pmin_pmax.wast + simd_f32x4_rounding.wast + simd_f64x2.wast + simd_f64x2_arith.wast + simd_f64x2_cmp.wast + simd_f64x2_pmin_pmax.wast + simd_f64x2_rounding.wast + simd_i16x8_arith.wast + simd_i16x8_arith2.wast + simd_i16x8_cmp.wast + simd_i16x8_extadd_pairwise_i8x16.wast + simd_i16x8_extmul_i8x16.wast + simd_i16x8_q15mulr_sat_s.wast + simd_i16x8_sat_arith.wast + simd_i32x4_arith.wast + simd_i32x4_arith2.wast + simd_i32x4_cmp.wast + simd_i32x4_dot_i16x8.wast + simd_i32x4_extadd_pairwise_i16x8.wast + simd_i32x4_extmul_i16x8.wast + simd_i32x4_trunc_sat_f32x4.wast + simd_i32x4_trunc_sat_f64x2.wast + simd_i64x2_arith.wast + simd_i64x2_arith2.wast + simd_i64x2_cmp.wast + simd_i64x2_extmul_i32x4.wast + simd_i8x16_arith.wast + simd_i8x16_arith2.wast + simd_i8x16_cmp.wast + simd_i8x16_sat_arith.wast + simd_int_to_int_extend.wast + simd_lane.wast + simd_linking.wast + simd_load.wast + simd_load16_lane.wast + simd_load32_lane.wast + simd_load64_lane.wast + simd_load8_lane.wast + simd_load_extend.wast + simd_load_splat.wast + simd_load_zero.wast + simd_select.wast + simd_splat.wast + simd_store.wast + simd_store16_lane.wast + simd_store32_lane.wast + simd_store64_lane.wast + simd_store8_lane.wast + token.wast + unreached-invalid.wast + utf8-custom-section-id.wast + utf8-import-field.wast + utf8-import-module.wast + utf8-invalid-encoding.wast + + SpecV1AddressTest.test82, + SpecV1AddressTest.test83, + SpecV1AddressTest.test84, + SpecV1AddressTest.test85, + SpecV1AddressTest.test86, + SpecV1AddressTest.test87, + SpecV1AddressTest.test88, + SpecV1AddressTest.test89, + SpecV1AddressTest.test90, + SpecV1AddressTest.test91, + SpecV1AddressTest.test206, + SpecV1AddressTest.test207, + SpecV1AddressTest.test208, + SpecV1AddressTest.test209, + SpecV1AddressTest.test210, + SpecV1AddressTest.test211, + SpecV1AddressTest.test212, + SpecV1AddressTest.test213, + SpecV1AddressTest.test214, + SpecV1AddressTest.test215, + SpecV1AddressTest.test216, + SpecV1AddressTest.test217, + SpecV1AddressTest.test218, + SpecV1AddressTest.test219, + SpecV1AddressTest.test238, + SpecV1AddressTest.test239, + SpecV1AddressTest.test258, + SpecV1AddressTest.test259, + SpecV1TrapsTest.test23, + SpecV1TrapsTest.test24, + SpecV1TrapsTest.test25, + SpecV1TrapsTest.test26, + SpecV1TrapsTest.test28, + SpecV1TrapsTest.test29, + SpecV1TrapsTest.test30, + SpecV1TrapsTest.test31, + SpecV1TrapsTest.test32, + SpecV1TrapsTest.test33 + + + + + wasm-test-gen + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + + default-testCompile + + + + --add-modules + java.sql + --add-modules + java.desktop + + + + + + + + + + + java11 + + 11 + + + + + org.apache.maven.plugins + maven-compiler-plugin + + + default-testCompile + + + false + + + + + + + + + diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/MachineFactorySourceCompiler.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/MachineFactorySourceCompiler.java new file mode 100644 index 000000000..1e5ce3ea0 --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/MachineFactorySourceCompiler.java @@ -0,0 +1,269 @@ +package com.dylibso.chicory.source.compiler; + +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.runtime.Machine; +import com.dylibso.chicory.source.compiler.internal.Compiler; +import com.dylibso.chicory.source.compiler.internal.JavaSourceCompiler; +import com.dylibso.chicory.source.compiler.internal.SimpleSourceCodeCollector; +import com.dylibso.chicory.source.compiler.internal.SourceCodeCollector; +import com.dylibso.chicory.wasm.ChicoryException; +import com.dylibso.chicory.wasm.WasmModule; +import java.io.File; +import java.io.IOException; +import java.lang.reflect.Constructor; +import java.net.URL; +import java.net.URLClassLoader; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Map; +import java.util.function.Function; + +/** + * Compiles WASM function bodies to Java source code that can be compiled and used as a machine + * factory for {@link Instance}'s. + */ +public final class MachineFactorySourceCompiler { + + private MachineFactorySourceCompiler() {} + + /** + * The compile method reference can be used as machine factory in instance builders. + * + * 
+     * var instance = Instance.builder(Parser.parse(is))
+     *         .withMachineFactory(MachineFactorySourceCompiler::compile)
+     *         .build();
+     *
+ * + *

Every instance created by the builder will pay the cost of compiling the module. + * + * @see #compile(WasmModule) If you want to compile the module only once for multiple instances. + */ + public static Machine compile(Instance instance) { + return compile(instance.module()).apply(instance); + } + + /** + * Compiles a machine factory that can be used in instance builders. The module is only compiled + * once and the machine factory is reused for every instance created by the builder. + * + * 

+     * var module  = Parser.parse(is);
+     * var builder = Instance.builder(module)
+     *         .withMachineFactory(MachineFactorySourceCompiler.compile(module));
+     * var instance1 = builder.build();
+     * var instance2 = builder.build();
+     *
+ */ + public static Function compile(WasmModule module) { + return new MachineFactory(module); + } + + /** + * Configures a compiler that can compile a machine factory. The builder allows you to + * configure the compiler options used to compile the module to Java source. + */ + public static Builder builder(WasmModule module) { + return new Builder(module); + } + + public static final class Builder { + private final WasmModule module; + private String className; + private Path compileTargetDir; + + private boolean dumpSources; + + private Builder(WasmModule module) { + this.module = module; + } + + public Builder withClassName(String className) { + this.className = className; + return this; + } + + public Builder withCompileTargetDir(Path compileTargetDir) { + this.compileTargetDir = compileTargetDir; + return this; + } + + public Builder withDumpSources(boolean dumpSources) { + this.dumpSources = dumpSources; + return this; + } + + /** + * Generate and dump sources without compiling to bytecode. + * Useful for dumping sources even when modules are invalid. + */ + public void generateAndDumpSources() { + SourceCodeCollector collector = new SimpleSourceCodeCollector(); + String finalClassName = className != null ? className : Compiler.DEFAULT_CLASS_NAME; + try { + var compilerBuilder = Compiler.builder(module).withSourceCodeCollector(collector); + if (className != null) { + compilerBuilder.withClassName(className); + } + compilerBuilder.build().compile(); + } catch (Throwable e) { + try { + String errorSource = + "// Source generation failed: " + + e.getClass().getSimpleName() + + ": " + + e.getMessage() + + "\n" + + "// Stack trace:\n" + + java.util.Arrays.stream(e.getStackTrace()) + .limit(10) + .map(st -> "// " + st.toString()) + .collect(java.util.stream.Collectors.joining("\n")); + collector.putMainClass(finalClassName, errorSource); + } catch (Throwable e2) { + String fallbackSource = + "// Source generation failed and error reporting also failed: " + + e2.getMessage(); + try { + collector.putMainClass(finalClassName, fallbackSource); + } catch (Throwable e3) { + // Last resort - at least try to dump something + } + } + } finally { + if (dumpSources) { + dumpSourcesToTarget(collector); + } + } + } + + public Function compile() { + SourceCodeCollector collector = new SimpleSourceCodeCollector(); + try { + var compilerBuilder = Compiler.builder(module).withSourceCodeCollector(collector); + if (className != null) { + compilerBuilder.withClassName(className); + } + compilerBuilder.build().compile(); + } finally { + if (dumpSources) { + dumpSourcesToTarget(collector); + } + } + + try { + Path targetDir = compileTargetDir; + if (targetDir == null) { + targetDir = Files.createTempDirectory("chicory-compiled-"); + } + + String classpath = buildClasspath(); + JavaSourceCompiler.compile(collector.sourceFiles(), targetDir, classpath); + + String mainClassName = collector.mainClassName(); + Class machineClass = loadClass(mainClassName, targetDir); + + try { + Constructor constructor = machineClass.getConstructor(Instance.class); + return instance -> { + try { + return (Machine) constructor.newInstance(instance); + } catch (ReflectiveOperationException e) { + throw new ChicoryException("Failed to instantiate machine", e); + } + }; + } catch (NoSuchMethodException e) { + throw new ChicoryException( + "Failed to find constructor for " + mainClassName + "(Instance)", e); + } + } catch (IOException e) { + throw new ChicoryException("Failed to compile Java sources", e); + } + } + + private String buildClasspath() { + String fullClasspath = System.getProperty("java.class.path"); + + // Prepend runtime.jar if found (for library distribution compatibility) + Class instanceClass = Instance.class; + String resourcePath = instanceClass.getName().replace('.', '/') + ".class"; + URL resource = instanceClass.getClassLoader().getResource(resourcePath); + if (resource != null) { + String path = resource.getPath(); + if (path.contains("!")) { + String jarPath = path.substring(0, path.indexOf("!")); + if (jarPath.startsWith("file:")) { + jarPath = jarPath.substring(5); + } + if (!fullClasspath.contains(jarPath)) { + return jarPath + File.pathSeparator + fullClasspath; + } + } + } + return fullClasspath; + } + + private Class loadClass(String className, Path classDir) throws IOException { + try { + URL url = classDir.toUri().toURL(); + URLClassLoader classLoader = + new URLClassLoader(new URL[] {url}, getClass().getClassLoader()); + return classLoader.loadClass(className); + } catch (ClassNotFoundException e) { + throw new ChicoryException("Failed to load compiled class: " + className, e); + } + } + + private void dumpSourcesToTarget(SourceCodeCollector collector) { + try { + String classPath = + getClass().getProtectionDomain().getCodeSource().getLocation().getPath(); + Path targetDir = Path.of(classPath).getParent(); + Path dumpDir = targetDir.resolve("source-dump"); + Files.createDirectories(dumpDir); + + for (Map.Entry entry : collector.sourceFiles().entrySet()) { + String collectedClassName = entry.getKey(); + String source = entry.getValue(); + + int lastDot = collectedClassName.lastIndexOf('.'); + String packagePath = + lastDot > 0 ? collectedClassName.substring(0, lastDot) : ""; + String simpleName = + lastDot > 0 + ? collectedClassName.substring(lastDot + 1) + : collectedClassName; + + Path packageDir = + packagePath.isEmpty() + ? dumpDir + : dumpDir.resolve(packagePath.replace('.', File.separatorChar)); + Files.createDirectories(packageDir); + + Path sourceFile = packageDir.resolve(simpleName + ".java"); + Files.writeString(sourceFile, source); + } + } catch (IOException | RuntimeException e) { + // Ignore - test-only debugging feature + } + } + } + + private static final class MachineFactory implements Function { + private final WasmModule module; + private final Function factory; + + MachineFactory(WasmModule module) { + this.module = module; + this.factory = builder(module).compile(); + } + + @Override + public Machine apply(Instance instance) { + if (instance.module() != module) { + throw new IllegalArgumentException("Instance module does not match factory module"); + } + return factory.apply(instance); + } + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/Compiler.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/Compiler.java new file mode 100644 index 000000000..3ef02df5a --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/Compiler.java @@ -0,0 +1,113 @@ +package com.dylibso.chicory.source.compiler.internal; + +import static java.util.Objects.requireNonNull; + +import com.dylibso.chicory.wasm.WasmModule; +import com.dylibso.chicory.wasm.types.ExternalType; +import com.dylibso.chicory.wasm.types.FunctionType; +import java.util.List; + +/** + * Minimal Java-source compiler that mirrors the high-level structure of the ASM-based compiler. + * + *

For now this: + *

    + *
  • analyzes the first non-imported function,
    • + *
  • generates a single Java class using {@link SourceCodeEmitter},
    • + *
  • prints the generated source to stdout.
    • + *
+ * + * All ASM bytecode generation and class collector machinery from the original compiler has been + * intentionally removed to keep things simple while we iterate on the source generator. + */ +public final class Compiler { + + public static final String DEFAULT_CLASS_NAME = "com.dylibso.chicory.gen.CompiledMachine"; + + private final String className; + private final WasmModule module; + private final WasmAnalyzer analyzer; + private final int functionImports; + private final List functionTypes; + private final SourceCodeCollector collector; + + private Compiler(WasmModule module, String className, SourceCodeCollector collector) { + this.className = requireNonNull(className, "className"); + this.module = requireNonNull(module, "module"); + this.analyzer = new WasmAnalyzer(module); + this.functionImports = module.importSection().count(ExternalType.FUNCTION); + this.collector = collector != null ? collector : new SimpleSourceCodeCollector(); + this.functionTypes = analyzer.functionTypes(); + } + + public static Builder builder(WasmModule module) { + return new Builder(module); + } + + public static final class Builder { + private final WasmModule module; + private String className; + private SourceCodeCollector collector; + + private Builder(WasmModule module) { + this.module = module; + } + + public Builder withClassName(String className) { + this.className = className; + return this; + } + + public Builder withSourceCodeCollector(SourceCodeCollector collector) { + this.collector = collector; + return this; + } + + public Compiler build() { + var className = this.className; + if (className == null) { + className = DEFAULT_CLASS_NAME; + } + + return new Compiler(module, className, collector); + } + } + + /** + * Compile the module to Java source files. + */ + public CompilerResult compile() { + String source; + try { + source = compileToSource(); + } catch (RuntimeException e) { + source = + "// Source generation failed: " + + e.getClass().getSimpleName() + + ": " + + e.getMessage() + + "\n" + + "// Stack trace:\n" + + java.util.Arrays.stream(e.getStackTrace()) + .limit(5) + .map(st -> "// " + st.toString()) + .collect(java.util.stream.Collectors.joining("\n")); + } + collector.putMainClass(className, source); + return new CompilerResult(collector); + } + + /** + * Generate Java source code for the module and return as string. + * + *

Generates code for ALL functions in the module, not just the first one. + */ + private String compileToSource() { + int lastDot = className.lastIndexOf('.'); + String packageName = lastDot > 0 ? className.substring(0, lastDot) : ""; + String simpleClassName = lastDot > 0 ? className.substring(lastDot + 1) : className; + + return SourceCodeEmitter.generateSource( + packageName, simpleClassName, module, analyzer, functionTypes, functionImports); + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerInstruction.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerInstruction.java new file mode 100644 index 000000000..270e6e78f --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerInstruction.java @@ -0,0 +1,60 @@ +package com.dylibso.chicory.source.compiler.internal; + +import java.util.Arrays; +import java.util.stream.LongStream; + +final class CompilerInstruction { + public static final long[] EMPTY = new long[0]; + + private final CompilerOpCode opcode; + private final long[] operands; + + public CompilerInstruction(CompilerOpCode opcode) { + this(opcode, EMPTY); + } + + public CompilerInstruction(CompilerOpCode opcode, long... operands) { + this.opcode = opcode; + this.operands = operands; + } + + public CompilerOpCode opcode() { + return opcode; + } + + public LongStream operands() { + return Arrays.stream(operands); + } + + public int operandCount() { + return operands.length; + } + + public long operand(int index) { + return operands[index]; + } + + @Override + public String toString() { + if (operands.length == 0) { + return opcode.toString(); + } + if (operands.length == 1) { + return opcode + " " + operands[0]; + } + return opcode + " " + Arrays.toString(operands); + } + + public long[] labelTargets() { + switch (opcode) { + case GOTO: + case IFEQ: + case IFNE: + case SWITCH: + case TRY_CATCH_BLOCK: + return operands; + default: + return EMPTY; + } + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerOpCode.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerOpCode.java new file mode 100644 index 000000000..01063b445 --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerOpCode.java @@ -0,0 +1,325 @@ +package com.dylibso.chicory.source.compiler.internal; + +import com.dylibso.chicory.wasm.types.OpCode; +import java.util.EnumMap; +import java.util.Map; +import java.util.Optional; + +enum CompilerOpCode { + LABEL, + DROP_KEEP, + TRAP, + GOTO, + IFEQ, + IFNE, + SWITCH, + // Structured control flow opcodes (Java primitives) + BLOCK_ENTER, + LOOP_ENTER, + IF_ENTER, + ELSE_ENTER, + SCOPE_EXIT, + BREAK, + BREAK_IF, + CONTINUE, + CONTINUE_IF, + RETURN(OpCode.RETURN), + CALL(OpCode.CALL), + CALL_INDIRECT(OpCode.CALL_INDIRECT), + DROP(OpCode.DROP), + SELECT(OpCode.SELECT), + LOCAL_GET(OpCode.LOCAL_GET), + LOCAL_SET(OpCode.LOCAL_SET), + LOCAL_TEE(OpCode.LOCAL_TEE), + GLOBAL_GET(OpCode.GLOBAL_GET), + GLOBAL_SET(OpCode.GLOBAL_SET), + TABLE_GET(OpCode.TABLE_GET), + TABLE_SET(OpCode.TABLE_SET), + I32_LOAD(OpCode.I32_LOAD), + I64_LOAD(OpCode.I64_LOAD), + F32_LOAD(OpCode.F32_LOAD), + F64_LOAD(OpCode.F64_LOAD), + I32_LOAD8_S(OpCode.I32_LOAD8_S), + I32_LOAD8_U(OpCode.I32_LOAD8_U), + I32_LOAD16_S(OpCode.I32_LOAD16_S), + I32_LOAD16_U(OpCode.I32_LOAD16_U), + I64_LOAD8_S(OpCode.I64_LOAD8_S), + I64_LOAD8_U(OpCode.I64_LOAD8_U), + I64_LOAD16_S(OpCode.I64_LOAD16_S), + I64_LOAD16_U(OpCode.I64_LOAD16_U), + I64_LOAD32_S(OpCode.I64_LOAD32_S), + I64_LOAD32_U(OpCode.I64_LOAD32_U), + I32_STORE(OpCode.I32_STORE), + I64_STORE(OpCode.I64_STORE), + F32_STORE(OpCode.F32_STORE), + F64_STORE(OpCode.F64_STORE), + I32_STORE8(OpCode.I32_STORE8), + I32_STORE16(OpCode.I32_STORE16), + I64_STORE8(OpCode.I64_STORE8), + I64_STORE16(OpCode.I64_STORE16), + I64_STORE32(OpCode.I64_STORE32), + MEMORY_SIZE(OpCode.MEMORY_SIZE), + MEMORY_GROW(OpCode.MEMORY_GROW), + I32_CONST(OpCode.I32_CONST), + I64_CONST(OpCode.I64_CONST), + F32_CONST(OpCode.F32_CONST), + F64_CONST(OpCode.F64_CONST), + I32_EQZ(OpCode.I32_EQZ), + I32_EQ(OpCode.I32_EQ), + I32_NE(OpCode.I32_NE), + I32_LT_S(OpCode.I32_LT_S), + I32_LT_U(OpCode.I32_LT_U), + I32_GT_S(OpCode.I32_GT_S), + I32_GT_U(OpCode.I32_GT_U), + I32_LE_S(OpCode.I32_LE_S), + I32_LE_U(OpCode.I32_LE_U), + I32_GE_S(OpCode.I32_GE_S), + I32_GE_U(OpCode.I32_GE_U), + I64_EQZ(OpCode.I64_EQZ), + I64_EQ(OpCode.I64_EQ), + I64_NE(OpCode.I64_NE), + I64_LT_S(OpCode.I64_LT_S), + I64_LT_U(OpCode.I64_LT_U), + I64_GT_S(OpCode.I64_GT_S), + I64_GT_U(OpCode.I64_GT_U), + I64_LE_S(OpCode.I64_LE_S), + I64_LE_U(OpCode.I64_LE_U), + I64_GE_S(OpCode.I64_GE_S), + I64_GE_U(OpCode.I64_GE_U), + F32_EQ(OpCode.F32_EQ), + F32_NE(OpCode.F32_NE), + F32_LT(OpCode.F32_LT), + F32_GT(OpCode.F32_GT), + F32_LE(OpCode.F32_LE), + F32_GE(OpCode.F32_GE), + F64_EQ(OpCode.F64_EQ), + F64_NE(OpCode.F64_NE), + F64_LT(OpCode.F64_LT), + F64_GT(OpCode.F64_GT), + F64_LE(OpCode.F64_LE), + F64_GE(OpCode.F64_GE), + I32_CLZ(OpCode.I32_CLZ), + I32_CTZ(OpCode.I32_CTZ), + I32_POPCNT(OpCode.I32_POPCNT), + I32_ADD(OpCode.I32_ADD), + I32_SUB(OpCode.I32_SUB), + I32_MUL(OpCode.I32_MUL), + I32_DIV_S(OpCode.I32_DIV_S), + I32_DIV_U(OpCode.I32_DIV_U), + I32_REM_S(OpCode.I32_REM_S), + I32_REM_U(OpCode.I32_REM_U), + I32_AND(OpCode.I32_AND), + I32_OR(OpCode.I32_OR), + I32_XOR(OpCode.I32_XOR), + I32_SHL(OpCode.I32_SHL), + I32_SHR_S(OpCode.I32_SHR_S), + I32_SHR_U(OpCode.I32_SHR_U), + I32_ROTL(OpCode.I32_ROTL), + I32_ROTR(OpCode.I32_ROTR), + I64_CLZ(OpCode.I64_CLZ), + I64_CTZ(OpCode.I64_CTZ), + I64_POPCNT(OpCode.I64_POPCNT), + I64_ADD(OpCode.I64_ADD), + I64_SUB(OpCode.I64_SUB), + I64_MUL(OpCode.I64_MUL), + I64_DIV_S(OpCode.I64_DIV_S), + I64_DIV_U(OpCode.I64_DIV_U), + I64_REM_S(OpCode.I64_REM_S), + I64_REM_U(OpCode.I64_REM_U), + I64_AND(OpCode.I64_AND), + I64_OR(OpCode.I64_OR), + I64_XOR(OpCode.I64_XOR), + I64_SHL(OpCode.I64_SHL), + I64_SHR_S(OpCode.I64_SHR_S), + I64_SHR_U(OpCode.I64_SHR_U), + I64_ROTL(OpCode.I64_ROTL), + I64_ROTR(OpCode.I64_ROTR), + F32_ABS(OpCode.F32_ABS), + F32_NEG(OpCode.F32_NEG), + F32_CEIL(OpCode.F32_CEIL), + F32_FLOOR(OpCode.F32_FLOOR), + F32_TRUNC(OpCode.F32_TRUNC), + F32_NEAREST(OpCode.F32_NEAREST), + F32_SQRT(OpCode.F32_SQRT), + F32_ADD(OpCode.F32_ADD), + F32_SUB(OpCode.F32_SUB), + F32_MUL(OpCode.F32_MUL), + F32_DIV(OpCode.F32_DIV), + F32_MIN(OpCode.F32_MIN), + F32_MAX(OpCode.F32_MAX), + F32_COPYSIGN(OpCode.F32_COPYSIGN), + F64_ABS(OpCode.F64_ABS), + F64_NEG(OpCode.F64_NEG), + F64_CEIL(OpCode.F64_CEIL), + F64_FLOOR(OpCode.F64_FLOOR), + F64_TRUNC(OpCode.F64_TRUNC), + F64_NEAREST(OpCode.F64_NEAREST), + F64_SQRT(OpCode.F64_SQRT), + F64_ADD(OpCode.F64_ADD), + F64_SUB(OpCode.F64_SUB), + F64_MUL(OpCode.F64_MUL), + F64_DIV(OpCode.F64_DIV), + F64_MIN(OpCode.F64_MIN), + F64_MAX(OpCode.F64_MAX), + F64_COPYSIGN(OpCode.F64_COPYSIGN), + I32_WRAP_I64(OpCode.I32_WRAP_I64), + I32_TRUNC_F32_S(OpCode.I32_TRUNC_F32_S), + I32_TRUNC_F32_U(OpCode.I32_TRUNC_F32_U), + I32_TRUNC_F64_S(OpCode.I32_TRUNC_F64_S), + I32_TRUNC_F64_U(OpCode.I32_TRUNC_F64_U), + I64_EXTEND_I32_S(OpCode.I64_EXTEND_I32_S), + I64_EXTEND_I32_U(OpCode.I64_EXTEND_I32_U), + I64_TRUNC_F32_S(OpCode.I64_TRUNC_F32_S), + I64_TRUNC_F32_U(OpCode.I64_TRUNC_F32_U), + I64_TRUNC_F64_S(OpCode.I64_TRUNC_F64_S), + I64_TRUNC_F64_U(OpCode.I64_TRUNC_F64_U), + F32_CONVERT_I32_S(OpCode.F32_CONVERT_I32_S), + F32_CONVERT_I32_U(OpCode.F32_CONVERT_I32_U), + F32_CONVERT_I64_S(OpCode.F32_CONVERT_I64_S), + F32_CONVERT_I64_U(OpCode.F32_CONVERT_I64_U), + F32_DEMOTE_F64(OpCode.F32_DEMOTE_F64), + F64_CONVERT_I32_S(OpCode.F64_CONVERT_I32_S), + F64_CONVERT_I32_U(OpCode.F64_CONVERT_I32_U), + F64_CONVERT_I64_S(OpCode.F64_CONVERT_I64_S), + F64_CONVERT_I64_U(OpCode.F64_CONVERT_I64_U), + F64_PROMOTE_F32(OpCode.F64_PROMOTE_F32), + I32_REINTERPRET_F32(OpCode.I32_REINTERPRET_F32), + I64_REINTERPRET_F64(OpCode.I64_REINTERPRET_F64), + F32_REINTERPRET_I32(OpCode.F32_REINTERPRET_I32), + F64_REINTERPRET_I64(OpCode.F64_REINTERPRET_I64), + I32_EXTEND_8_S(OpCode.I32_EXTEND_8_S), + I32_EXTEND_16_S(OpCode.I32_EXTEND_16_S), + I64_EXTEND_8_S(OpCode.I64_EXTEND_8_S), + I64_EXTEND_16_S(OpCode.I64_EXTEND_16_S), + I64_EXTEND_32_S(OpCode.I64_EXTEND_32_S), + REF_NULL(OpCode.REF_NULL), + REF_IS_NULL(OpCode.REF_IS_NULL), + REF_FUNC(OpCode.REF_FUNC), + I32_TRUNC_SAT_F32_S(OpCode.I32_TRUNC_SAT_F32_S), + I32_TRUNC_SAT_F32_U(OpCode.I32_TRUNC_SAT_F32_U), + I32_TRUNC_SAT_F64_S(OpCode.I32_TRUNC_SAT_F64_S), + I32_TRUNC_SAT_F64_U(OpCode.I32_TRUNC_SAT_F64_U), + I64_TRUNC_SAT_F32_S(OpCode.I64_TRUNC_SAT_F32_S), + I64_TRUNC_SAT_F32_U(OpCode.I64_TRUNC_SAT_F32_U), + I64_TRUNC_SAT_F64_S(OpCode.I64_TRUNC_SAT_F64_S), + I64_TRUNC_SAT_F64_U(OpCode.I64_TRUNC_SAT_F64_U), + MEMORY_INIT(OpCode.MEMORY_INIT), + DATA_DROP(OpCode.DATA_DROP), + MEMORY_COPY(OpCode.MEMORY_COPY), + MEMORY_FILL(OpCode.MEMORY_FILL), + TABLE_INIT(OpCode.TABLE_INIT), + ELEM_DROP(OpCode.ELEM_DROP), + TABLE_COPY(OpCode.TABLE_COPY), + TABLE_GROW(OpCode.TABLE_GROW), + TABLE_SIZE(OpCode.TABLE_SIZE), + TABLE_FILL(OpCode.TABLE_FILL), + THROW(OpCode.THROW), + THROW_REF(OpCode.THROW_REF), + TRY_CATCH_BLOCK(OpCode.TRY_TABLE), + CATCH_START, + CATCH_END, + CATCH_UNBOX_PARAMS, + CATCH_COMPARE_TAG, + CATCH_REGISTER_EXCEPTION, + ATOMIC_INT_LOAD(OpCode.I32_ATOMIC_LOAD), + ATOMIC_INT_LOAD_BYTE(OpCode.I32_ATOMIC_LOAD8_U), + ATOMIC_INT_LOAD_SHORT(OpCode.I32_ATOMIC_LOAD16_U), + ATOMIC_LONG_LOAD(OpCode.I64_ATOMIC_LOAD), + ATOMIC_LONG_LOAD_BYTE(OpCode.I64_ATOMIC_LOAD8_U), + ATOMIC_LONG_LOAD_SHORT(OpCode.I64_ATOMIC_LOAD16_U), + ATOMIC_LONG_LOAD_INT(OpCode.I64_ATOMIC_LOAD32_U), + ATOMIC_INT_STORE(OpCode.I32_ATOMIC_STORE), + ATOMIC_LONG_STORE(OpCode.I64_ATOMIC_STORE), + ATOMIC_INT_STORE_BYTE(OpCode.I32_ATOMIC_STORE8), + ATOMIC_INT_STORE_SHORT(OpCode.I32_ATOMIC_STORE16), + ATOMIC_LONG_STORE_BYTE(OpCode.I64_ATOMIC_STORE8), + ATOMIC_LONG_STORE_SHORT(OpCode.I64_ATOMIC_STORE16), + ATOMIC_LONG_STORE_INT(OpCode.I64_ATOMIC_STORE32), + // Atomic RMW (I32) + ATOMIC_INT_RMW_ADD(OpCode.I32_ATOMIC_RMW_ADD), + ATOMIC_INT_RMW_SUB(OpCode.I32_ATOMIC_RMW_SUB), + ATOMIC_INT_RMW_AND(OpCode.I32_ATOMIC_RMW_AND), + ATOMIC_INT_RMW_OR(OpCode.I32_ATOMIC_RMW_OR), + ATOMIC_INT_RMW_XOR(OpCode.I32_ATOMIC_RMW_XOR), + ATOMIC_INT_RMW_XCHG(OpCode.I32_ATOMIC_RMW_XCHG), + ATOMIC_INT_RMW_CMPXCHG(OpCode.I32_ATOMIC_RMW_CMPXCHG), + ATOMIC_INT_RMW8_ADD_U(OpCode.I32_ATOMIC_RMW8_ADD_U), + ATOMIC_INT_RMW8_SUB_U(OpCode.I32_ATOMIC_RMW8_SUB_U), + ATOMIC_INT_RMW8_AND_U(OpCode.I32_ATOMIC_RMW8_AND_U), + ATOMIC_INT_RMW8_OR_U(OpCode.I32_ATOMIC_RMW8_OR_U), + ATOMIC_INT_RMW8_XOR_U(OpCode.I32_ATOMIC_RMW8_XOR_U), + ATOMIC_INT_RMW8_XCHG_U(OpCode.I32_ATOMIC_RMW8_XCHG_U), + ATOMIC_INT_RMW8_CMPXCHG_U(OpCode.I32_ATOMIC_RMW8_CMPXCHG_U), + ATOMIC_INT_RMW16_ADD_U(OpCode.I32_ATOMIC_RMW16_ADD_U), + ATOMIC_INT_RMW16_SUB_U(OpCode.I32_ATOMIC_RMW16_SUB_U), + ATOMIC_INT_RMW16_AND_U(OpCode.I32_ATOMIC_RMW16_AND_U), + ATOMIC_INT_RMW16_OR_U(OpCode.I32_ATOMIC_RMW16_OR_U), + ATOMIC_INT_RMW16_XOR_U(OpCode.I32_ATOMIC_RMW16_XOR_U), + ATOMIC_INT_RMW16_XCHG_U(OpCode.I32_ATOMIC_RMW16_XCHG_U), + ATOMIC_INT_RMW16_CMPXCHG_U(OpCode.I32_ATOMIC_RMW16_CMPXCHG_U), + // Atomic RMW (I64) + ATOMIC_LONG_RMW_ADD(OpCode.I64_ATOMIC_RMW_ADD), + ATOMIC_LONG_RMW_SUB(OpCode.I64_ATOMIC_RMW_SUB), + ATOMIC_LONG_RMW_AND(OpCode.I64_ATOMIC_RMW_AND), + ATOMIC_LONG_RMW_OR(OpCode.I64_ATOMIC_RMW_OR), + ATOMIC_LONG_RMW_XOR(OpCode.I64_ATOMIC_RMW_XOR), + ATOMIC_LONG_RMW_XCHG(OpCode.I64_ATOMIC_RMW_XCHG), + ATOMIC_LONG_RMW_CMPXCHG(OpCode.I64_ATOMIC_RMW_CMPXCHG), + ATOMIC_LONG_RMW8_ADD_U(OpCode.I64_ATOMIC_RMW8_ADD_U), + ATOMIC_LONG_RMW8_SUB_U(OpCode.I64_ATOMIC_RMW8_SUB_U), + ATOMIC_LONG_RMW8_AND_U(OpCode.I64_ATOMIC_RMW8_AND_U), + ATOMIC_LONG_RMW8_OR_U(OpCode.I64_ATOMIC_RMW8_OR_U), + ATOMIC_LONG_RMW8_XOR_U(OpCode.I64_ATOMIC_RMW8_XOR_U), + ATOMIC_LONG_RMW8_XCHG_U(OpCode.I64_ATOMIC_RMW8_XCHG_U), + ATOMIC_LONG_RMW8_CMPXCHG_U(OpCode.I64_ATOMIC_RMW8_CMPXCHG_U), + ATOMIC_LONG_RMW16_ADD_U(OpCode.I64_ATOMIC_RMW16_ADD_U), + ATOMIC_LONG_RMW16_SUB_U(OpCode.I64_ATOMIC_RMW16_SUB_U), + ATOMIC_LONG_RMW16_AND_U(OpCode.I64_ATOMIC_RMW16_AND_U), + ATOMIC_LONG_RMW16_OR_U(OpCode.I64_ATOMIC_RMW16_OR_U), + ATOMIC_LONG_RMW16_XOR_U(OpCode.I64_ATOMIC_RMW16_XOR_U), + ATOMIC_LONG_RMW16_XCHG_U(OpCode.I64_ATOMIC_RMW16_XCHG_U), + ATOMIC_LONG_RMW16_CMPXCHG_U(OpCode.I64_ATOMIC_RMW16_CMPXCHG_U), + ATOMIC_LONG_RMW32_ADD_U(OpCode.I64_ATOMIC_RMW32_ADD_U), + ATOMIC_LONG_RMW32_SUB_U(OpCode.I64_ATOMIC_RMW32_SUB_U), + ATOMIC_LONG_RMW32_AND_U(OpCode.I64_ATOMIC_RMW32_AND_U), + ATOMIC_LONG_RMW32_OR_U(OpCode.I64_ATOMIC_RMW32_OR_U), + ATOMIC_LONG_RMW32_XOR_U(OpCode.I64_ATOMIC_RMW32_XOR_U), + ATOMIC_LONG_RMW32_XCHG_U(OpCode.I64_ATOMIC_RMW32_XCHG_U), + ATOMIC_LONG_RMW32_CMPXCHG_U(OpCode.I64_ATOMIC_RMW32_CMPXCHG_U), + // Wait/Notify + MEM_ATOMIC_WAIT32(OpCode.MEM_ATOMIC_WAIT32), + MEM_ATOMIC_WAIT64(OpCode.MEM_ATOMIC_WAIT64), + MEM_ATOMIC_NOTIFY(OpCode.MEM_ATOMIC_NOTIFY), + ATOMIC_FENCE(OpCode.ATOMIC_FENCE), + ; + + private final Optional opcode; + + private static final Map OPCODES = new EnumMap<>(OpCode.class); + + static { + for (CompilerOpCode v : values()) { + v.opcode.ifPresent(opcode -> OPCODES.put(opcode, v)); + } + } + + CompilerOpCode() { + this.opcode = Optional.empty(); + } + + CompilerOpCode(OpCode opcode) { + this.opcode = Optional.of(opcode); + } + + public OpCode opcode() { + return opcode.orElseThrow(() -> new IllegalStateException("No opcode for " + this)); + } + + public static CompilerOpCode of(OpCode opcode) { + CompilerOpCode value = OPCODES.get(opcode); + if (value == null) { + throw new IllegalArgumentException("No compiler opcode for " + opcode); + } + return value; + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerResult.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerResult.java new file mode 100644 index 000000000..e5bf5bdea --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerResult.java @@ -0,0 +1,19 @@ +package com.dylibso.chicory.source.compiler.internal; + +/** + * Compiler result for the source compiler. + * + *

Contains the source code collector with generated Java files. + */ +public final class CompilerResult { + + private final SourceCodeCollector collector; + + public CompilerResult(SourceCodeCollector collector) { + this.collector = collector; + } + + public SourceCodeCollector collector() { + return collector; + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerUtil.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerUtil.java new file mode 100644 index 000000000..8774df36b --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/CompilerUtil.java @@ -0,0 +1,28 @@ +package com.dylibso.chicory.source.compiler.internal; + +import com.dylibso.chicory.wasm.types.FunctionBody; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.ValType; + +/** + * Minimal compiler utilities needed by the source compiler. + * + *

This intentionally omits all ASM-related helpers from the original bytecode compiler and keeps + * only what is required for the Java source generator (e.g., computing local types). + */ +final class CompilerUtil { + + private CompilerUtil() {} + + /** + * Return the WASM type of a local (parameter or function-local), matching the original + * compiler's behaviour. + */ + public static ValType localType(FunctionType type, FunctionBody body, int localIndex) { + if (localIndex < type.params().size()) { + return type.params().get(localIndex); + } else { + return body.localTypes().get(localIndex - type.params().size()); + } + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/JavaSourceCompiler.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/JavaSourceCompiler.java new file mode 100644 index 000000000..736c9ac47 --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/JavaSourceCompiler.java @@ -0,0 +1,148 @@ +package com.dylibso.chicory.source.compiler.internal; + +import com.dylibso.chicory.wasm.ChicoryException; +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import javax.tools.Diagnostic; +import javax.tools.DiagnosticCollector; +import javax.tools.JavaCompiler; +import javax.tools.JavaFileObject; +import javax.tools.StandardJavaFileManager; +import javax.tools.StandardLocation; +import javax.tools.ToolProvider; + +/** + * Compiles Java source files to bytecode using the standard JavaCompiler API. + */ +public final class JavaSourceCompiler { + + private JavaSourceCompiler() {} + + /** + * Compile Java source files to a target directory. + * + * @param sourceFiles map of fully qualified class names to source code + * @param targetDir directory where .class files will be written + * @param classpath classpath for compilation (can include runtime dependencies) + * @throws ChicoryException if compilation fails + */ + public static void compile(Map sourceFiles, Path targetDir, String classpath) { + try { + // Create target directory + Files.createDirectories(targetDir); + + // Write source files to temporary directory + Path tempSourceDir = Files.createTempDirectory("chicory-source-"); + try { + List sourceFileList = new ArrayList<>(); + for (Map.Entry entry : sourceFiles.entrySet()) { + String className = entry.getKey(); + String source = entry.getValue(); + + // Convert package name to directory structure + String packagePath = className.substring(0, className.lastIndexOf('.')); + Path packageDir = + tempSourceDir.resolve(packagePath.replace('.', File.separatorChar)); + Files.createDirectories(packageDir); + + // Write source file + String simpleName = className.substring(className.lastIndexOf('.') + 1); + Path sourceFile = packageDir.resolve(simpleName + ".java"); + Files.writeString(sourceFile, source); + sourceFileList.add(sourceFile.toFile()); + } + + // Get Java compiler + JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); + if (compiler == null) { + throw new ChicoryException( + "No Java compiler available. Make sure you're running with a JDK, not a" + + " JRE."); + } + + StandardJavaFileManager fileManager = + compiler.getStandardFileManager(null, null, null); + + // Set output directory + fileManager.setLocation( + StandardLocation.CLASS_OUTPUT, Arrays.asList(targetDir.toFile())); + + // Set classpath if provided + if (classpath != null && !classpath.isEmpty()) { + List classpathFiles = new ArrayList<>(); + @SuppressWarnings("StringSplitter") + String[] entries = classpath.split(File.pathSeparator); + for (String cpEntry : entries) { + if (!cpEntry.isEmpty()) { + File cpFile = new File(cpEntry); + if (cpFile.exists()) { + classpathFiles.add(cpFile); + } + } + } + if (!classpathFiles.isEmpty()) { + fileManager.setLocation(StandardLocation.CLASS_PATH, classpathFiles); + } + } + + // Get compilation units + Iterable compilationUnits = + fileManager.getJavaFileObjectsFromFiles(sourceFileList); + + // Compile with diagnostics + DiagnosticCollector diagnostics = new DiagnosticCollector<>(); + JavaCompiler.CompilationTask task = + compiler.getTask( + null, fileManager, diagnostics, null, null, compilationUnits); + + boolean success = task.call(); + fileManager.close(); + + if (!success) { + StringBuilder errorMsg = new StringBuilder("Compilation failed:\n"); + for (Diagnostic diagnostic : + diagnostics.getDiagnostics()) { + if (diagnostic.getKind() == Diagnostic.Kind.ERROR) { + errorMsg.append(diagnostic.getKind()) + .append(": ") + .append(diagnostic.getMessage(null)) + .append(" at ") + .append(diagnostic.getLineNumber()) + .append(":") + .append(diagnostic.getColumnNumber()) + .append("\n"); + } + } + throw new ChicoryException(errorMsg.toString()); + } + } finally { + // Clean up temp directory + deleteRecursively(tempSourceDir); + } + } catch (IOException e) { + throw new ChicoryException("Failed to compile Java sources", e); + } + } + + private static void deleteRecursively(Path path) throws IOException { + if (Files.exists(path)) { + try (var stream = Files.walk(path)) { + stream.sorted((a, b) -> b.compareTo(a)) + .forEach( + p -> { + try { + Files.delete(p); + } catch (IOException e) { + // Ignore cleanup errors + } + }); + } + } + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/MethodSplitter.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/MethodSplitter.java new file mode 100644 index 000000000..c8a3448ad --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/MethodSplitter.java @@ -0,0 +1,1317 @@ +package com.dylibso.chicory.source.compiler.internal; + +import com.github.javaparser.StaticJavaParser; +import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration; +import com.github.javaparser.ast.body.MethodDeclaration; +import com.github.javaparser.ast.body.Parameter; +import com.github.javaparser.ast.expr.ArrayAccessExpr; +import com.github.javaparser.ast.expr.IntegerLiteralExpr; +import com.github.javaparser.ast.expr.NameExpr; +import com.github.javaparser.ast.stmt.BlockStmt; +import com.github.javaparser.ast.stmt.BreakStmt; +import com.github.javaparser.ast.stmt.ContinueStmt; +import com.github.javaparser.ast.stmt.ExpressionStmt; +import com.github.javaparser.ast.stmt.LabeledStmt; +import com.github.javaparser.ast.stmt.ReturnStmt; +import com.github.javaparser.ast.stmt.Statement; +import com.github.javaparser.ast.stmt.SwitchEntry; +import com.github.javaparser.ast.stmt.SwitchStmt; +import com.github.javaparser.ast.type.ArrayType; +import com.github.javaparser.ast.type.PrimitiveType; +import com.github.javaparser.ast.visitor.ModifierVisitor; +import com.github.javaparser.ast.visitor.Visitable; +import com.github.javaparser.ast.visitor.VoidVisitorAdapter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * Splits too-large generated methods into smaller helper methods to stay within Java's 64KB + * bytecode limit per method. + * + *

The approach: 1. Convert local variables to int[]/long[]/float[]/double[] arrays shared + * between main method and helpers. 2. Extract large labeled blocks into static helper methods. 3. + * Handle outer break/continue via a status array and labeled do-while wrapper. + */ +final class MethodSplitter { + + private MethodSplitter() {} + + /** + * Methods with source representation larger than this (in characters) get split. ~80K chars of + * source is a conservative estimate for ~40-60KB of bytecode. + */ + private static final int MAX_METHOD_SIZE = 50_000; + + private static final String HELPER_BREAK_LABEL = "_hb"; + + /** + * When extracting a block from a helper that already has _hb: wrapper (nested extraction), + * parent status codes (_hs[0] = CODE; break _hb;) are offset by this value to avoid + * collision with the new helper's own return codes. + */ + private static final int PARENT_STATUS_OFFSET = 10000; + + /** + * Maximum number of splitting iterations. Safety cap to prevent infinite loops if the + * heuristics fail to make progress. + */ + private static final int MAX_ITERATIONS = 100; + + /** Split any too-large static methods in the class. */ + static void splitLargeMethods(ClassOrInterfaceDeclaration clazz) { + boolean changed = true; + int iteration = 0; + while (changed && iteration < MAX_ITERATIONS) { + changed = false; + iteration++; + for (MethodDeclaration method : new ArrayList<>(clazz.getMethods())) { + if (method.isStatic() && methodSize(method) > MAX_METHOD_SIZE) { + if (!hasArrayLocals(method)) { + convertLocalsToArrays(method); + } + if (extractLargestBlock(clazz, method)) { + changed = true; + } else if (splitLargeSwitch(clazz, method)) { + changed = true; + } + } + } + } + } + + private static int methodSize(MethodDeclaration method) { + return method.getBody().map(b -> b.toString().length()).orElse(0); + } + + private static boolean hasArrayLocals(MethodDeclaration method) { + for (Parameter param : method.getParameters()) { + if (param.getNameAsString().equals("iL") || param.getNameAsString().equals("lL")) { + return true; + } + } + return method.getBody() + .map( + body -> + body.getStatements().stream() + .anyMatch(s -> s.toString().contains("int[] iL"))) + .orElse(false); + } + + // ----------------------------------------------------------------------- + // Local-to-array conversion + // ----------------------------------------------------------------------- + + private static final class VarInfo { + final String type; // "int", "long", "float", "double" + final int arrayIndex; + + VarInfo(String type, int arrayIndex) { + this.type = type; + this.arrayIndex = arrayIndex; + } + } + + private static void convertLocalsToArrays(MethodDeclaration method) { + BlockStmt body = method.getBody().orElseThrow(); + + // Collect variables: params + local declarations at method body level + Map varMap = new LinkedHashMap<>(); + Map typeCounts = new HashMap<>(); + typeCounts.put("int", 0); + typeCounts.put("long", 0); + typeCounts.put("float", 0); + typeCounts.put("double", 0); + + // Map function parameters + List paramNames = new ArrayList<>(); + for (Parameter param : method.getParameters()) { + String pName = param.getNameAsString(); + if (pName.equals("memory") || pName.equals("instance")) { + continue; + } + String pType = primitiveTypeName(param.getType().toString()); + if (pType == null) { + continue; + } + int idx = typeCounts.getOrDefault(pType, 0); + varMap.put(pName, new VarInfo(pType, idx)); + typeCounts.put(pType, idx + 1); + paramNames.add(pName); + } + + // Collect local variable declarations at method body level + List toRemove = new ArrayList<>(); + for (Statement stmt : body.getStatements()) { + if (!(stmt instanceof ExpressionStmt)) { + continue; + } + ExpressionStmt exprStmt = (ExpressionStmt) stmt; + if (!(exprStmt.getExpression() + instanceof com.github.javaparser.ast.expr.VariableDeclarationExpr)) { + continue; + } + com.github.javaparser.ast.expr.VariableDeclarationExpr varDecl = + (com.github.javaparser.ast.expr.VariableDeclarationExpr) + exprStmt.getExpression(); + boolean anyMapped = false; + for (com.github.javaparser.ast.body.VariableDeclarator declarator : + varDecl.getVariables()) { + String vName = declarator.getNameAsString(); + String vType = primitiveTypeName(declarator.getType().toString()); + if (vType == null) { + continue; // skip non-primitive types + } + int idx = typeCounts.getOrDefault(vType, 0); + varMap.put(vName, new VarInfo(vType, idx)); + typeCounts.put(vType, idx + 1); + anyMapped = true; + } + if (anyMapped) { + toRemove.add(stmt); + } + } + + if (varMap.isEmpty()) { + return; + } + + // Remove original declarations + for (Statement stmt : toRemove) { + body.getStatements().remove(stmt); + } + + // Replace all NameExpr references BEFORE inserting copy statements, + // so that copy statements like "iL[0] = arg0;" aren't transformed + // into "iL[0] = iL[0];" + replaceVarReferences(body, varMap); + + // Insert array declarations at the top + int insertIdx = 0; + boolean hasInt = typeCounts.get("int") > 0; + boolean hasLong = typeCounts.get("long") > 0; + boolean hasFloat = typeCounts.get("float") > 0; + boolean hasDouble = typeCounts.get("double") > 0; + + if (hasInt) { + body.getStatements() + .add( + insertIdx++, + StaticJavaParser.parseStatement( + "int[] iL = new int[" + typeCounts.get("int") + "];")); + } + if (hasLong) { + body.getStatements() + .add( + insertIdx++, + StaticJavaParser.parseStatement( + "long[] lL = new long[" + typeCounts.get("long") + "];")); + } + if (hasFloat) { + body.getStatements() + .add( + insertIdx++, + StaticJavaParser.parseStatement( + "float[] fL = new float[" + typeCounts.get("float") + "];")); + } + if (hasDouble) { + body.getStatements() + .add( + insertIdx++, + StaticJavaParser.parseStatement( + "double[] dL = new double[" + typeCounts.get("double") + "];")); + } + + // Copy parameters into arrays (after replacement, so param names are still valid) + for (String pName : paramNames) { + VarInfo info = varMap.get(pName); + body.getStatements() + .add( + insertIdx++, + StaticJavaParser.parseStatement(arrayRef(info) + " = " + pName + ";")); + } + } + + private static String primitiveTypeName(String typeStr) { + switch (typeStr) { + case "int": + return "int"; + case "long": + return "long"; + case "float": + return "float"; + case "double": + return "double"; + default: + return null; + } + } + + private static String arrayName(String type) { + switch (type) { + case "int": + return "iL"; + case "long": + return "lL"; + case "float": + return "fL"; + case "double": + return "dL"; + default: + throw new IllegalArgumentException("Unknown type: " + type); + } + } + + private static String arrayRef(VarInfo info) { + return arrayName(info.type) + "[" + info.arrayIndex + "]"; + } + + private static void replaceVarReferences(BlockStmt body, Map varMap) { + body.accept( + new ModifierVisitor() { + @Override + public Visitable visit(NameExpr n, Void arg) { + VarInfo info = varMap.get(n.getNameAsString()); + if (info != null) { + return new ArrayAccessExpr( + new NameExpr(arrayName(info.type)), + new IntegerLiteralExpr(String.valueOf(info.arrayIndex))); + } + return super.visit(n, null); + } + }, + null); + } + + // ----------------------------------------------------------------------- + // Block extraction + // ----------------------------------------------------------------------- + + /** + * Find and extract a suitable labeled block into a helper method. Returns true if an + * extraction was performed. + * + *

Picks the block closest to half the method size to ensure geometric convergence. + * Extracting the absolute largest block (which is often nearly the entire method) just moves + * the problem to the helper without reducing total size, causing an infinite loop. + */ + private static boolean extractLargestBlock( + ClassOrInterfaceDeclaration clazz, MethodDeclaration method) { + BlockStmt body = method.getBody().orElseThrow(); + int mSize = methodSize(method); + + // Find the best block to extract: closest to half method size + LabeledStmt best = findBestBlockToExtract(body, mSize); + if (best == null) { + return false; + } + + // Only extract if the block is a significant portion of the method + int blockSize = best.toString().length(); + if (blockSize < MAX_METHOD_SIZE / 4) { + return false; + } + + String baseName = baseMethodName(method.getNameAsString()); + int helperIdx = countHelpers(clazz, baseName); + String helperName = baseName + "__h" + helperIdx; + + doExtractBlock(clazz, method, best, helperName); + return true; + } + + /** Extract the base function name (e.g. "func_804" from "func_804__h3"). */ + private static String baseMethodName(String name) { + int idx = name.indexOf("__h"); + if (idx > 0 && idx < name.length() - 3) { + // Check if everything after "__h" is digits (it's a helper suffix) + String suffix = name.substring(idx + 3); + if (suffix.chars().allMatch(Character::isDigit)) { + return name.substring(0, idx); + } + } + return name; + } + + private static int countHelpers(ClassOrInterfaceDeclaration clazz, String baseName) { + int count = 0; + for (MethodDeclaration m : clazz.getMethods()) { + if (m.getNameAsString().startsWith(baseName + "__h")) { + count++; + } + } + return count; + } + + /** + * Find the best labeled block to extract from a method of size {@code methodSize}. Prefers the + * block whose size is closest to half the method size. This ensures that both the remaining + * method and the new helper are roughly half the original, giving geometric convergence. + * + *

Blocks larger than 75% of the method are rejected because extracting them just moves + * nearly all the code to a helper without reducing it, causing the splitter to loop. + */ + private static LabeledStmt findBestBlockToExtract(BlockStmt root, int methodSize) { + int target = methodSize / 2; + int maxBlockSize = (int) (methodSize * 0.75); + + final LabeledStmt[] best = {null}; + final int[] bestDist = {Integer.MAX_VALUE}; + + root.accept( + new VoidVisitorAdapter() { + @Override + public void visit(LabeledStmt n, Void arg) { + // Only extract labeled blocks (not loops directly) + if (n.getStatement() instanceof BlockStmt) { + int size = n.toString().length(); + if (size <= maxBlockSize && size >= MAX_METHOD_SIZE / 4) { + int dist = Math.abs(size - target); + if (dist < bestDist[0]) { + bestDist[0] = dist; + best[0] = n; + } + } + } + super.visit(n, null); + } + }, + null); + + return best[0]; + } + + private static void doExtractBlock( + ClassOrInterfaceDeclaration clazz, + MethodDeclaration method, + LabeledStmt labeledStmt, + String helperName) { + + String blockLabel = labeledStmt.getLabel().getIdentifier(); + BlockStmt blockBody = (BlockStmt) labeledStmt.getStatement(); + + // Find which array types are used by scanning the method parameters and body + boolean hasInt = false; + boolean hasLong = false; + boolean hasFloat = false; + boolean hasDouble = false; + for (Parameter param : method.getParameters()) { + switch (param.getNameAsString()) { + case "iL": + hasInt = true; + break; + case "lL": + hasLong = true; + break; + case "fL": + hasFloat = true; + break; + case "dL": + hasDouble = true; + break; + default: + break; + } + } + // Also check local declarations (for original func_N methods) + BlockStmt methodBody = method.getBody().orElseThrow(); + String bodyStr = methodBody.toString(); + if (bodyStr.contains("int[] iL")) { + hasInt = true; + } + if (bodyStr.contains("long[] lL")) { + hasLong = true; + } + if (bodyStr.contains("float[] fL")) { + hasFloat = true; + } + if (bodyStr.contains("double[] dL")) { + hasDouble = true; + } + + // Find outer labels: break/continue targets not defined within the block + Set definedLabels = new HashSet<>(); + collectDefinedLabels(blockBody, definedLabels); + + Map outerLabels = new LinkedHashMap<>(); // label -> "break" or "continue" + collectOuterReferences(blockBody, definedLabels, blockLabel, outerLabels); + // _hb is always handled by the do-while wrapper in nested helpers, + // don't treat as outer — the new helper also wraps in _hb: do {} while(false) + outerLabels.remove(HELPER_BREAK_LABEL); + + // Assign return codes + Map returnCodes = new LinkedHashMap<>(); + int code = 1; + for (String label : outerLabels.keySet()) { + returnCodes.put(label, code++); + } + + // Check if any return statements exist in the block (for method-level returns) + boolean hasReturns = hasReturnStatements(blockBody); + int returnCode = hasReturns ? code++ : -1; + + // Clone the block content for the helper + BlockStmt innerBody = blockBody.clone(); + + // For nested extractions (extracting from a helper that already has _hb: wrapper), + // offset parent status codes to avoid collision with the new helper's own codes. + boolean isNestedExtraction = methodBody.toString().contains("_hb:"); + if (isNestedExtraction) { + offsetParentStatusCodes(innerBody); + } + + // Replace outer break/continue and method returns with: + // _hs[0] = CODE; break _hb; + // Self-label breaks become: break _hb; (with _hs[0] staying 0 = normal) + String returnType = method.getType().toString(); + String returnArray = returnArrayForType(returnType); + replaceWithBreaks(innerBody, blockLabel, returnCodes, returnCode, returnArray); + + // Find variables used in the block but not declared in it (e.g. callArgs_N, + // callResult_N). These are long[] temporaries from the caller scope that need + // to be re-declared inside the helper. + Set undeclaredVars = findUndeclaredArrayVars(innerBody); + + // Wrap in: int[] _hs = {0}; _hb: do { innerBody } while (false); return _hs[0]; + BlockStmt helperBody = new BlockStmt(); + helperBody.addStatement(StaticJavaParser.parseStatement("int[] _hs = { 0 };")); + + // Add declarations for undeclared array variables + for (String varName : undeclaredVars) { + helperBody.addStatement( + StaticJavaParser.parseStatement("long[] " + varName + " = null;")); + } + + // Build the do-while wrapper: _hb: do { ... } while (false); + BlockStmt doBody = new BlockStmt(); + for (Statement stmt : innerBody.getStatements()) { + doBody.addStatement(stmt.clone()); + } + + // Create: do { doBody } while (false); + com.github.javaparser.ast.stmt.DoStmt doStmt = + new com.github.javaparser.ast.stmt.DoStmt( + doBody, StaticJavaParser.parseExpression("false")); + + // Wrap in label: _hb: do { ... } while (false); + LabeledStmt labeledDoWhile = new LabeledStmt(HELPER_BREAK_LABEL, doStmt); + + helperBody.addStatement(labeledDoWhile); + helperBody.addStatement(StaticJavaParser.parseStatement("return _hs[0];")); + + // Create the helper method + MethodDeclaration helper = + clazz.addMethod(helperName, Modifier.Keyword.PRIVATE, Modifier.Keyword.STATIC) + .setType(PrimitiveType.intType()); + + if (hasInt) { + helper.addParameter(new ArrayType(PrimitiveType.intType()), "iL"); + } + if (hasLong) { + helper.addParameter(new ArrayType(PrimitiveType.longType()), "lL"); + } + if (hasFloat) { + helper.addParameter(new ArrayType(PrimitiveType.floatType()), "fL"); + } + if (hasDouble) { + helper.addParameter(new ArrayType(PrimitiveType.doubleType()), "dL"); + } + helper.addParameter( + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Memory"), + "memory"); + helper.addParameter( + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Instance"), + "instance"); + + helper.setBody(helperBody); + + // Replace the block content with dispatch code + BlockStmt newBlockBody = new BlockStmt(); + + // Build helper call with unique dispatch variable name + // Extract the numeric suffix from the helper name for a unique dispatch var + String helperSuffix = helperName.substring(helperName.lastIndexOf("__h") + 3); + String dispatchVar = "_d" + helperSuffix; + StringBuilder callExpr = new StringBuilder(); + callExpr.append("int ").append(dispatchVar).append(" = ").append(helperName).append("("); + List callArgs = new ArrayList<>(); + if (hasInt) { + callArgs.add("iL"); + } + if (hasLong) { + callArgs.add("lL"); + } + if (hasFloat) { + callArgs.add("fL"); + } + if (hasDouble) { + callArgs.add("dL"); + } + callArgs.add("memory"); + callArgs.add("instance"); + callExpr.append(String.join(", ", callArgs)); + callExpr.append(");"); + newBlockBody.addStatement(StaticJavaParser.parseStatement(callExpr.toString())); + + // Add dispatch for outer labels + for (Map.Entry entry : returnCodes.entrySet()) { + String label = entry.getKey(); + int rc = entry.getValue(); + String branchType = outerLabels.get(label); + newBlockBody.addStatement( + StaticJavaParser.parseStatement( + "if (" + + dispatchVar + + " == " + + rc + + ") " + + branchType + + " " + + label + + ";")); + } + + // Add dispatch for method return + if (hasReturns) { + if (returnType.equals("void")) { + newBlockBody.addStatement( + StaticJavaParser.parseStatement( + "if (" + dispatchVar + " == " + returnCode + ") return;")); + } else { + String arrayForReturn = returnArrayForType(returnType); + newBlockBody.addStatement( + StaticJavaParser.parseStatement( + "if (" + + dispatchVar + + " == " + + returnCode + + ") return " + + arrayForReturn + + "[0];")); + } + } + + // Propagate offset parent status codes back to the parent's do-while. + // Parent codes were offset by PARENT_STATUS_OFFSET to avoid collision with + // the new helper's own return codes. Subtract the offset and propagate. + if (isNestedExtraction) { + newBlockBody.addStatement( + StaticJavaParser.parseStatement( + "if (" + + dispatchVar + + " >= " + + PARENT_STATUS_OFFSET + + ") { _hs[0] = (" + + dispatchVar + + " - " + + PARENT_STATUS_OFFSET + + "); break _hb; }")); + } + + // Replace the labeled block's body + labeledStmt.setStatement(newBlockBody); + } + + // ----------------------------------------------------------------------- + // Switch splitting: split a large switch into multiple helper methods + // ----------------------------------------------------------------------- + + /** + * Split a large switch statement by delegating groups of cases to helper methods. Returns true + * if a split was performed. + */ + private static boolean splitLargeSwitch( + ClassOrInterfaceDeclaration clazz, MethodDeclaration method) { + BlockStmt body = method.getBody().orElseThrow(); + + // Find the largest SwitchStmt in the method body + SwitchStmt targetSwitch = null; + // Search top-level statements, and also inside do-while wrappers + for (Statement stmt : body.getStatements()) { + SwitchStmt found = findSwitchStmt(stmt); + if (found != null) { + if (targetSwitch == null + || found.toString().length() > targetSwitch.toString().length()) { + targetSwitch = found; + } + } + } + + if (targetSwitch == null || targetSwitch.getEntries().size() < 4) { + return false; + } + + // Determine which array types the method uses + boolean hasInt = false; + boolean hasLong = false; + boolean hasFloat = false; + boolean hasDouble = false; + for (Parameter param : method.getParameters()) { + switch (param.getNameAsString()) { + case "iL": + hasInt = true; + break; + case "lL": + hasLong = true; + break; + case "fL": + hasFloat = true; + break; + case "dL": + hasDouble = true; + break; + default: + break; + } + } + String bodyStr = body.toString(); + if (bodyStr.contains("int[] iL")) { + hasInt = true; + } + if (bodyStr.contains("long[] lL")) { + hasLong = true; + } + if (bodyStr.contains("float[] fL")) { + hasFloat = true; + } + if (bodyStr.contains("double[] dL")) { + hasDouble = true; + } + + // Split the switch entries in half + List entries = targetSwitch.getEntries(); + int mid = entries.size() / 2; + + // Find the split point: use the first case label value of the second half + // to create an if/else dispatch + List firstHalf = new ArrayList<>(entries.subList(0, mid)); + List secondHalf = new ArrayList<>(entries.subList(mid, entries.size())); + + String methodName = method.getNameAsString(); + int helperCount = countHelpers(clazz, methodName); + + // Build parameter name list for helpers + List paramNames = new ArrayList<>(); + if (hasInt) { + paramNames.add("iL"); + } + if (hasLong) { + paramNames.add("lL"); + } + if (hasFloat) { + paramNames.add("fL"); + } + if (hasDouble) { + paramNames.add("dL"); + } + paramNames.add("memory"); + paramNames.add("instance"); + + String selector = targetSwitch.getSelector().toString(); + + // Use a parameter name for the selector to avoid referencing local variables + // in the helpers. The parent will pre-compute the selector value. + String selectorParam = "_sel"; + + // Collect outer label references from ALL switch entries. + // These are break/continue targets that reference labels outside the switch. + // Wrap the switch in a temp statement for label analysis. + Map outerLabels = new LinkedHashMap<>(); + Set definedInSwitch = new HashSet<>(); + SwitchStmt tempSwitch = targetSwitch.clone(); + collectDefinedLabels(tempSwitch, definedInSwitch); + collectOuterReferences(tempSwitch, definedInSwitch, "_hb", outerLabels); + // _hb is always handled by the do-while wrapper, don't treat as outer + outerLabels.remove(HELPER_BREAK_LABEL); + + // Assign status codes for outer labels (starting at 1) + Map labelCodes = new LinkedHashMap<>(); + int labelCode = 1; + for (String label : outerLabels.keySet()) { + labelCodes.put(label, labelCode++); + } + + // Create helper for first half (uses _sel parameter instead of original selector) + String helper1Name = methodName + "_helper" + helperCount; + createSwitchHelper( + clazz, + helper1Name, + selectorParam, + firstHalf, + hasInt, + hasLong, + hasFloat, + hasDouble, + labelCodes); + + // Create helper for second half + String helper2Name = methodName + "_helper" + (helperCount + 1); + createSwitchHelper( + clazz, + helper2Name, + selectorParam, + secondHalf, + hasInt, + hasLong, + hasFloat, + hasDouble, + labelCodes); + + // Replace the switch statement with dispatch to the two helpers + // Find the minimum case value of the second half for the split point + int splitValue = findMinCaseValue(secondHalf); + + // Add _sel as first arg, then the standard params + String argsStr = selectorParam + ", " + String.join(", ", paramNames); + + // Pre-compute selector value (unless the method already has _sel as a parameter), + // then dispatch to the correct helper + boolean methodHasSel = + method.getParameters().stream() + .anyMatch(p -> p.getNameAsString().equals(selectorParam)); + String selectorDecl = methodHasSel ? "" : "int " + selectorParam + " = " + selector + "; "; + + // Build dispatch code with outer label forwarding + StringBuilder dispatchBuilder = new StringBuilder(); + dispatchBuilder + .append("{ ") + .append(selectorDecl) + .append("int _sw; if (") + .append(selectorParam) + .append(" < ") + .append(splitValue) + .append(") { _sw = ") + .append(helper1Name) + .append("(") + .append(argsStr) + .append("); } else { _sw = ") + .append(helper2Name) + .append("(") + .append(argsStr) + .append("); } "); + + // Add dispatch for outer labels + for (Map.Entry lc : labelCodes.entrySet()) { + String label = lc.getKey(); + int lcode = lc.getValue(); + String branchType = outerLabels.get(label); + dispatchBuilder + .append("if (_sw == ") + .append(lcode) + .append(") ") + .append(branchType) + .append(" ") + .append(label) + .append("; "); + } + + // Propagate any remaining non-zero status to the parent helper's do-while. + // Only if the method already has _hb (it's an extracted helper), otherwise + // all label codes are explicitly dispatched and this is unreachable. + boolean hasHelperWrapper = bodyStr.contains("_hb:"); + if (hasHelperWrapper) { + dispatchBuilder.append("if (_sw != 0) { _hs[0] = _sw; break _hb; } "); + } + dispatchBuilder.append("}"); + + // Replace the switch with the dispatch + targetSwitch.replace(StaticJavaParser.parseStatement(dispatchBuilder.toString())); + return true; + } + + private static SwitchStmt findSwitchStmt(Statement stmt) { + if (stmt instanceof SwitchStmt) { + return (SwitchStmt) stmt; + } + if (stmt instanceof LabeledStmt) { + return findSwitchStmt(((LabeledStmt) stmt).getStatement()); + } + if (stmt instanceof com.github.javaparser.ast.stmt.DoStmt) { + return findSwitchStmt(((com.github.javaparser.ast.stmt.DoStmt) stmt).getBody()); + } + if (stmt instanceof BlockStmt) { + for (Statement s : ((BlockStmt) stmt).getStatements()) { + SwitchStmt found = findSwitchStmt(s); + if (found != null) { + return found; + } + } + } + return null; + } + + private static int findMinCaseValue(List entries) { + for (SwitchEntry entry : entries) { + if (!entry.getLabels().isEmpty()) { + String label = entry.getLabels().get(0).toString(); + try { + return Integer.parseInt(label); + } catch (NumberFormatException e) { + return 0; + } + } + } + return 0; + } + + private static void createSwitchHelper( + ClassOrInterfaceDeclaration clazz, + String helperName, + String selector, + List entries, + boolean hasInt, + boolean hasLong, + boolean hasFloat, + boolean hasDouble, + Map labelCodes) { + + // Create new switch with only these entries, replacing return/break _hb + // with status-based dispatch, and outer label breaks with status codes + SwitchStmt newSwitch = + new SwitchStmt( + StaticJavaParser.parseExpression(selector), + new com.github.javaparser.ast.NodeList<>()); + for (SwitchEntry entry : entries) { + SwitchEntry cloned = entry.clone(); + // Replace "return X;" with "{ _hs[0] = X; break _hb; }" + // and outer label breaks with "{ _hs[0] = CODE; break _hb; }" + replaceReturnsAndBreaksWithStatus(cloned, labelCodes); + newSwitch.getEntries().add(cloned); + } + + // Wrap in do-while pattern: int[] _hs = {0}; _hb: do { switch } while(false); return + // _hs[0]; + BlockStmt helperBody = new BlockStmt(); + helperBody.addStatement(StaticJavaParser.parseStatement("int[] _hs = { 0 };")); + + BlockStmt doBody = new BlockStmt(); + doBody.addStatement(newSwitch); + + com.github.javaparser.ast.stmt.DoStmt doStmt = + new com.github.javaparser.ast.stmt.DoStmt( + doBody, StaticJavaParser.parseExpression("false")); + LabeledStmt labeledDoWhile = new LabeledStmt(HELPER_BREAK_LABEL, doStmt); + + helperBody.addStatement(labeledDoWhile); + helperBody.addStatement(StaticJavaParser.parseStatement("return _hs[0];")); + + MethodDeclaration helper = + clazz.addMethod(helperName, Modifier.Keyword.PRIVATE, Modifier.Keyword.STATIC) + .setType(PrimitiveType.intType()); + + // First parameter is the pre-computed selector value + helper.addParameter(PrimitiveType.intType(), selector); + + if (hasInt) { + helper.addParameter(new ArrayType(PrimitiveType.intType()), "iL"); + } + if (hasLong) { + helper.addParameter(new ArrayType(PrimitiveType.longType()), "lL"); + } + if (hasFloat) { + helper.addParameter(new ArrayType(PrimitiveType.floatType()), "fL"); + } + if (hasDouble) { + helper.addParameter(new ArrayType(PrimitiveType.doubleType()), "dL"); + } + helper.addParameter( + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Memory"), + "memory"); + helper.addParameter( + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Instance"), + "instance"); + + helper.setBody(helperBody); + } + + private static void replaceReturnsAndBreaksWithStatus( + SwitchEntry entry, Map labelCodes) { + // Collect labels defined within this entry + Set definedInEntry = new HashSet<>(); + collectDefinedLabels(entry, definedInEntry); + + entry.accept( + new ModifierVisitor() { + @Override + public Visitable visit(ReturnStmt n, Void arg) { + BlockStmt block = new BlockStmt(); + if (n.getExpression().isPresent()) { + String expr = n.getExpression().get().toString(); + block.addStatement( + StaticJavaParser.parseStatement("_hs[0] = " + expr + ";")); + } + block.addStatement(new BreakStmt(HELPER_BREAK_LABEL)); + return block; + } + + @Override + public Visitable visit(BreakStmt n, Void arg) { + if (n.getLabel().isPresent()) { + String label = n.getLabel().get().getIdentifier(); + // Skip _hb breaks (they target our own do-while) + if (HELPER_BREAK_LABEL.equals(label)) { + return super.visit(n, null); + } + // If this break targets a label defined within the entry, keep it + if (definedInEntry.contains(label)) { + return super.visit(n, null); + } + // Outer label break: convert to status code + if (labelCodes.containsKey(label)) { + BlockStmt block = new BlockStmt(); + block.addStatement( + StaticJavaParser.parseStatement( + "_hs[0] = " + labelCodes.get(label) + ";")); + block.addStatement(new BreakStmt(HELPER_BREAK_LABEL)); + return block; + } + } + return super.visit(n, null); + } + }, + null); + } + + private static String returnArrayForType(String returnType) { + switch (returnType) { + case "int": + return "iL"; + case "long": + return "lL"; + case "float": + return "fL"; + case "double": + return "dL"; + default: + return "iL"; + } + } + + // ----------------------------------------------------------------------- + // Undeclared variable detection + // ----------------------------------------------------------------------- + + /** + * Find array variable names used in the block but not declared within it. These are typically + * long[] temporaries (callArgs_N, callResult_N) declared at the parent method scope. + */ + private static Set findUndeclaredArrayVars(BlockStmt body) { + // Find all names used as array access targets (e.g., callResult_1[0]) + // or assigned to directly (e.g., callResult_1 = new long[2]) + Set usedNames = new HashSet<>(); + body.accept( + new VoidVisitorAdapter() { + @Override + public void visit(ArrayAccessExpr n, Void arg) { + if (n.getName() instanceof NameExpr) { + usedNames.add(((NameExpr) n.getName()).getNameAsString()); + } + super.visit(n, null); + } + + @Override + public void visit(com.github.javaparser.ast.expr.AssignExpr n, Void arg) { + if (n.getTarget() instanceof NameExpr) { + usedNames.add(((NameExpr) n.getTarget()).getNameAsString()); + } + super.visit(n, null); + } + }, + null); + + // Find all variable names declared within the block + Set declared = new HashSet<>(); + body.accept( + new VoidVisitorAdapter() { + @Override + public void visit( + com.github.javaparser.ast.expr.VariableDeclarationExpr n, Void arg) { + for (com.github.javaparser.ast.body.VariableDeclarator v : + n.getVariables()) { + declared.add(v.getNameAsString()); + } + super.visit(n, null); + } + }, + null); + + // Known names that are always available as parameters or status arrays + Set known = new HashSet<>(); + known.add("iL"); + known.add("lL"); + known.add("fL"); + known.add("dL"); + known.add("memory"); + known.add("instance"); + known.add("_hs"); + + usedNames.removeAll(declared); + usedNames.removeAll(known); + return usedNames; + } + + // ----------------------------------------------------------------------- + // Label analysis + // ----------------------------------------------------------------------- + + private static void collectDefinedLabels( + com.github.javaparser.ast.Node stmt, Set labels) { + stmt.accept( + new VoidVisitorAdapter() { + @Override + public void visit(LabeledStmt n, Void arg) { + labels.add(n.getLabel().getIdentifier()); + super.visit(n, null); + } + }, + null); + } + + private static void collectOuterReferences( + com.github.javaparser.ast.Node stmt, + Set definedLabels, + String selfLabel, + Map outerLabels) { + stmt.accept( + new VoidVisitorAdapter() { + @Override + public void visit(BreakStmt n, Void arg) { + n.getLabel() + .ifPresent( + label -> { + String name = label.getIdentifier(); + if (!definedLabels.contains(name)) { + // Self-label break means normal completion + if (!name.equals(selfLabel)) { + outerLabels.putIfAbsent(name, "break"); + } + } + }); + super.visit(n, null); + } + + @Override + public void visit(ContinueStmt n, Void arg) { + n.getLabel() + .ifPresent( + label -> { + String name = label.getIdentifier(); + if (!definedLabels.contains(name)) { + outerLabels.putIfAbsent(name, "continue"); + } + }); + super.visit(n, null); + } + }, + null); + } + + private static boolean hasReturnStatements(Statement stmt) { + final boolean[] found = {false}; + stmt.accept( + new VoidVisitorAdapter() { + @Override + public void visit(ReturnStmt n, Void arg) { + found[0] = true; + } + }, + null); + return found[0]; + } + + // ----------------------------------------------------------------------- + // Parent status code offsetting for nested extractions + // ----------------------------------------------------------------------- + + /** + * When extracting a block from a method that is already a helper (has _hb: wrapper), + * the extracted block may contain {@code _hs[0] = CODE; break _hb;} patterns from the + * parent's status system. These codes must be offset to avoid collision with the new + * helper's own return codes. + * + *

Also handles bare {@code break _hb;} (parent self-label break = status 0) by + * inserting {@code _hs[0] = PARENT_STATUS_OFFSET;} before the break. + */ + private static void offsetParentStatusCodes(BlockStmt body) { + // Step 1: Offset _hs[0] = CODE in { ...; _hs[0] = CODE; break _hb; } patterns + body.accept( + new VoidVisitorAdapter() { + @Override + public void visit(BlockStmt n, Void arg) { + // Visit children first + super.visit(n, null); + + List stmts = n.getStatements(); + for (int i = stmts.size() - 1; i >= 0; i--) { + if (isBreakHb(stmts.get(i)) + && i > 0 + && isHsAssignment(stmts.get(i - 1))) { + String valueStr = getHsValueString(stmts.get(i - 1)); + String offsetExpr; + try { + int code = Integer.parseInt(valueStr); + offsetExpr = String.valueOf(code + PARENT_STATUS_OFFSET); + } catch (NumberFormatException e) { + // Non-integer expression (e.g., "(_d2 - 10000)" from a + // previous nested extraction dispatch) — wrap with offset + offsetExpr = "(" + valueStr + ") + " + PARENT_STATUS_OFFSET; + } + stmts.set( + i - 1, + StaticJavaParser.parseStatement( + "_hs[0] = " + offsetExpr + ";")); + } + } + } + }, + null); + + // Step 2: Handle bare break _hb; (not preceded by _hs[0] = CODE;) + // by wrapping them with _hs[0] = PARENT_STATUS_OFFSET; break _hb; + body.accept( + new ModifierVisitor() { + @Override + public Visitable visit(BreakStmt n, Void arg) { + if (!isBreakHb(n)) { + return super.visit(n, null); + } + + // Check if preceded by _hs[0] assignment (already offset) + com.github.javaparser.ast.Node parent = n.getParentNode().orElse(null); + if (parent instanceof BlockStmt) { + BlockStmt parentBlock = (BlockStmt) parent; + int idx = parentBlock.getStatements().indexOf(n); + if (idx > 0 + && isHsAssignment(parentBlock.getStatements().get(idx - 1))) { + // Already handled in step 1 + return super.visit(n, null); + } + } + + // Bare break _hb; → wrap with offset status + BlockStmt wrapper = new BlockStmt(); + wrapper.addStatement( + StaticJavaParser.parseStatement( + "_hs[0] = " + PARENT_STATUS_OFFSET + ";")); + wrapper.addStatement(new BreakStmt(HELPER_BREAK_LABEL)); + return wrapper; + } + }, + null); + } + + private static boolean isBreakHb(Statement stmt) { + if (stmt instanceof BreakStmt) { + return ((BreakStmt) stmt) + .getLabel() + .map(l -> l.getIdentifier().equals(HELPER_BREAK_LABEL)) + .orElse(false); + } + return false; + } + + private static boolean isHsAssignment(Statement stmt) { + if (!(stmt instanceof ExpressionStmt)) { + return false; + } + ExpressionStmt exprStmt = (ExpressionStmt) stmt; + if (!(exprStmt.getExpression() instanceof com.github.javaparser.ast.expr.AssignExpr)) { + return false; + } + com.github.javaparser.ast.expr.AssignExpr assign = + (com.github.javaparser.ast.expr.AssignExpr) exprStmt.getExpression(); + if (!(assign.getTarget() instanceof ArrayAccessExpr)) { + return false; + } + ArrayAccessExpr target = (ArrayAccessExpr) assign.getTarget(); + return target.getName().toString().equals("_hs") + && target.getIndex().toString().equals("0"); + } + + private static String getHsValueString(Statement stmt) { + ExpressionStmt exprStmt = (ExpressionStmt) stmt; + com.github.javaparser.ast.expr.AssignExpr assign = + (com.github.javaparser.ast.expr.AssignExpr) exprStmt.getExpression(); + return assign.getValue().toString(); + } + + // ----------------------------------------------------------------------- + // Branch replacement: convert return/break/continue to break _hb with status + // ----------------------------------------------------------------------- + + private static void replaceWithBreaks( + BlockStmt body, + String selfLabel, + Map returnCodes, + int methodReturnCode, + String returnArray) { + + // Collect labels defined within the helper body + Set definedLabels = new HashSet<>(); + collectDefinedLabels(body, definedLabels); + + body.accept( + new ModifierVisitor() { + @Override + public Visitable visit(BreakStmt n, Void arg) { + if (n.getLabel().isPresent()) { + String label = n.getLabel().get().getIdentifier(); + if (label.equals(selfLabel)) { + // Self-label break = normal completion, status stays 0 + return new BreakStmt(HELPER_BREAK_LABEL); + } + if (!definedLabels.contains(label) && returnCodes.containsKey(label)) { + BlockStmt block = new BlockStmt(); + block.addStatement( + StaticJavaParser.parseStatement( + "_hs[0] = " + returnCodes.get(label) + ";")); + block.addStatement(new BreakStmt(HELPER_BREAK_LABEL)); + return block; + } + } + return super.visit(n, null); + } + + @Override + public Visitable visit(ContinueStmt n, Void arg) { + if (n.getLabel().isPresent()) { + String label = n.getLabel().get().getIdentifier(); + if (!definedLabels.contains(label) && returnCodes.containsKey(label)) { + BlockStmt block = new BlockStmt(); + block.addStatement( + StaticJavaParser.parseStatement( + "_hs[0] = " + returnCodes.get(label) + ";")); + block.addStatement(new BreakStmt(HELPER_BREAK_LABEL)); + return block; + } + } + return super.visit(n, null); + } + + @Override + public Visitable visit(ReturnStmt n, Void arg) { + if (methodReturnCode >= 0) { + BlockStmt block = new BlockStmt(); + if (n.getExpression().isPresent()) { + String expr = n.getExpression().get().toString(); + block.addStatement( + StaticJavaParser.parseStatement( + returnArray + "[0] = " + expr + ";")); + } + block.addStatement( + StaticJavaParser.parseStatement( + "_hs[0] = " + methodReturnCode + ";")); + block.addStatement(new BreakStmt(HELPER_BREAK_LABEL)); + return block; + } + return super.visit(n, null); + } + }, + null); + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SimpleSourceCodeCollector.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SimpleSourceCodeCollector.java new file mode 100644 index 000000000..25fb86173 --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SimpleSourceCodeCollector.java @@ -0,0 +1,44 @@ +package com.dylibso.chicory.source.compiler.internal; + +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * Simple implementation of SourceCodeCollector that stores source files in memory. + */ +public class SimpleSourceCodeCollector implements SourceCodeCollector { + private final LinkedHashMap sourceFiles = new LinkedHashMap<>(); + private String mainClass; + + @Override + public String mainClassName() { + return mainClass; + } + + @Override + public void putMainClass(String className, String source) { + this.mainClass = className; + // Ensure the main class comes first in order + var newSourceFiles = new LinkedHashMap(); + newSourceFiles.put(className, source); + newSourceFiles.putAll(this.sourceFiles); + this.sourceFiles.clear(); + this.sourceFiles.putAll(newSourceFiles); + } + + @Override + public void put(String className, String source) { + sourceFiles.put(className, source); + } + + @Override + public void putAll(SourceCodeCollector collector) { + sourceFiles.putAll(collector.sourceFiles()); + } + + @Override + public Map sourceFiles() { + return Collections.unmodifiableMap(sourceFiles); + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SourceCodeCollector.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SourceCodeCollector.java new file mode 100644 index 000000000..a2806485e --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SourceCodeCollector.java @@ -0,0 +1,23 @@ +package com.dylibso.chicory.source.compiler.internal; + +import java.util.Map; + +/** + * A collector that stores generated Java source files. + * + *

Similar to ClassCollector but for Java source code instead of bytecode. + */ +public interface SourceCodeCollector { + /** + * Main entry point - the fully qualified class name of the main generated class. + */ + String mainClassName(); + + void putMainClass(String className, String source); + + void put(String className, String source); + + void putAll(SourceCodeCollector collector); + + Map sourceFiles(); +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SourceCodeEmitter.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SourceCodeEmitter.java new file mode 100644 index 000000000..537babd55 --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SourceCodeEmitter.java @@ -0,0 +1,4372 @@ +package com.dylibso.chicory.source.compiler.internal; + +import com.dylibso.chicory.wasm.WasmModule; +import com.dylibso.chicory.wasm.types.FunctionBody; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.ValType; +import com.github.javaparser.StaticJavaParser; +import com.github.javaparser.ast.CompilationUnit; +import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration; +import com.github.javaparser.ast.body.MethodDeclaration; +import com.github.javaparser.ast.expr.AssignExpr; +import com.github.javaparser.ast.expr.BinaryExpr; +import com.github.javaparser.ast.expr.BooleanLiteralExpr; +import com.github.javaparser.ast.expr.CastExpr; +import com.github.javaparser.ast.expr.ConditionalExpr; +import com.github.javaparser.ast.expr.EnclosedExpr; +import com.github.javaparser.ast.expr.FieldAccessExpr; +import com.github.javaparser.ast.expr.IntegerLiteralExpr; +import com.github.javaparser.ast.expr.MethodCallExpr; +import com.github.javaparser.ast.expr.NameExpr; +import com.github.javaparser.ast.expr.SimpleName; +import com.github.javaparser.ast.expr.ThisExpr; +import com.github.javaparser.ast.expr.UnaryExpr; +import com.github.javaparser.ast.stmt.BlockStmt; +import com.github.javaparser.ast.stmt.BreakStmt; +import com.github.javaparser.ast.stmt.ContinueStmt; +import com.github.javaparser.ast.stmt.ExpressionStmt; +import com.github.javaparser.ast.stmt.IfStmt; +import com.github.javaparser.ast.stmt.LabeledStmt; +import com.github.javaparser.ast.stmt.ReturnStmt; +import com.github.javaparser.ast.stmt.Statement; +import com.github.javaparser.ast.stmt.ThrowStmt; +import com.github.javaparser.ast.stmt.WhileStmt; +import com.github.javaparser.ast.type.ArrayType; +import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.PrimitiveType; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.List; + +/** + * Source code emitters that mirror the ASM Emitters structure. + * Uses Java expressions to naturally leverage the Java operand stack, + * just like the ASM compiler uses the JVM operand stack. + */ +final class SourceCodeEmitter { + + private SourceCodeEmitter() {} + + /** Tracks scope nesting in the emitter for structured control flow. */ + private static final class EmitterScope { + final int label; + final String type; // "block", "loop", "if", "else" + final BlockStmt block; + final String[] resultVarNames; + final IfStmt ifStmt; // only for "if" scopes + final String[] paramVarNames; // only for "loop" scopes with params + // Snapshot of the expression stack at scope entry. Used to restore the + // stack after terminated blocks where DROP_KEEP may have consumed values + // belonging to outer scopes. + final List savedStack; + + EmitterScope( + int label, + String type, + BlockStmt block, + String[] resultVarNames, + IfStmt ifStmt, + List savedStack) { + this(label, type, block, resultVarNames, ifStmt, null, savedStack); + } + + EmitterScope( + int label, + String type, + BlockStmt block, + String[] resultVarNames, + IfStmt ifStmt, + String[] paramVarNames, + List savedStack) { + this.label = label; + this.type = type; + this.block = block; + this.resultVarNames = resultVarNames; + this.ifStmt = ifStmt; + this.paramVarNames = paramVarNames; + this.savedStack = savedStack; + } + } + + private static EmitterScope findScope(Deque scopeStack, int label) { + for (EmitterScope scope : scopeStack) { + if (scope.label == label) { + return scope; + } + } + return null; + } + + private static IfStmt createInterruptCheck() { + MethodCallExpr isInterruptedCall = new MethodCallExpr(); + isInterruptedCall.setScope(StaticJavaParser.parseExpression("Thread.currentThread()")); + isInterruptedCall.setName("isInterrupted"); + com.github.javaparser.ast.expr.ObjectCreationExpr exception = + new com.github.javaparser.ast.expr.ObjectCreationExpr(); + exception.setType( + StaticJavaParser.parseClassOrInterfaceType( + "com.dylibso.chicory.runtime.ChicoryInterruptedException")); + exception.addArgument( + new com.github.javaparser.ast.expr.StringLiteralExpr("Thread interrupted")); + ThrowStmt throwStmt = new ThrowStmt(exception); + return new IfStmt(isInterruptedCall, throwStmt, null); + } + + private static void emitInterruptCheck(BlockStmt block) { + block.addStatement(createInterruptCheck()); + } + + private static String javaTypeNameForId(long typeId) { + if (typeId == ValType.I32.id()) { + return "int"; + } else if (typeId == ValType.I64.id()) { + return "long"; + } else if (typeId == ValType.F32.id()) { + return "float"; + } else if (typeId == ValType.F64.id()) { + return "double"; + } + return "int"; // fallback for ref types + } + + private static String defaultValueForId(long typeId) { + if (typeId == ValType.I32.id()) { + return "0"; + } else if (typeId == ValType.I64.id()) { + return "0L"; + } else if (typeId == ValType.F32.id()) { + return "0.0f"; + } else if (typeId == ValType.F64.id()) { + return "0.0"; + } + return "0"; // fallback for ref types + } + + /** + * Generate Java source code for all functions in the module. + * Mirrors the structure of the ASM compiler's compileFunction method. + */ + public static String generateSource( + String packageName, + String className, + WasmModule module, + WasmAnalyzer analyzer, + List functionTypes, + int functionImports) { + + CompilationUnit cu = new CompilationUnit(packageName); + ClassOrInterfaceDeclaration clazz = + cu.addClass(className, Modifier.Keyword.PUBLIC, Modifier.Keyword.FINAL); + + // implements Machine + ClassOrInterfaceType machineType = + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Machine"); + clazz.addImplementedType(machineType); + + // field: private final Instance instance; + clazz.addField( + "com.dylibso.chicory.runtime.Instance", + "instance", + Modifier.Keyword.PRIVATE, + Modifier.Keyword.FINAL); + + // constructor: public C(Instance instance) { this.instance = instance; } + var ctor = + clazz.addConstructor(Modifier.Keyword.PUBLIC) + .addParameter("com.dylibso.chicory.runtime.Instance", "instance") + .createBody(); + ctor.addStatement( + new ExpressionStmt( + new AssignExpr( + new FieldAccessExpr(new ThisExpr(), "instance"), + new NameExpr("instance"), + AssignExpr.Operator.ASSIGN))); + + List globalTypes = analyzer.globalTypes(); + + // Generate func_xxx methods for all functions (public static, matching ASM compiler) + for (int funcId = 0; funcId < functionTypes.size(); funcId++) { + FunctionType functionType = functionTypes.get(funcId); + + if (funcId < functionImports) { + // Host function - delegate to instance + generateHostFunctionMethod(clazz, funcId, functionType); + } else { + // Regular function - generate full implementation + List instructions = analyzer.analyze(funcId); + FunctionBody body = module.codeSection().getFunctionBody(funcId - functionImports); + generateFunctionMethod( + clazz, + funcId, + functionType, + instructions, + body, + functionTypes, + module.typeSection().types(), + globalTypes); + // Generate call_xxx bridge method (matching ASM compiler) + generateCallFunctionMethod(clazz, className, funcId, functionType); + } + } + + // Generate call() method that dispatches to the appropriate func_xxx + generateCallMethod(clazz, className, functionTypes, functionImports); + + // Split any too-large methods to stay within Java's 64KB bytecode limit + MethodSplitter.splitLargeMethods(clazz); + + return cu.toString(); + } + + /** + * Generate the call() method that dispatches to the appropriate function. + */ + private static void generateCallMethod( + ClassOrInterfaceDeclaration clazz, + String className, + List functionTypes, + int functionImports) { + + MethodDeclaration callMethodDecl = + clazz.addMethod("call", Modifier.Keyword.PUBLIC) + .setType(new ArrayType(PrimitiveType.longType())); + callMethodDecl + .addParameter(PrimitiveType.intType(), "funcId") + .addParameter(new ArrayType(PrimitiveType.longType()), "args"); + + BlockStmt callBody = new BlockStmt(); + callMethodDecl.setBody(callBody); + + callBody.addStatement( + StaticJavaParser.parseStatement( + "com.dylibso.chicory.runtime.Memory memory = this.instance.memory();")); + + com.github.javaparser.ast.stmt.SwitchStmt switchStmt = + new com.github.javaparser.ast.stmt.SwitchStmt(); + switchStmt.setSelector(new NameExpr("funcId")); + + // Host functions all share the same case (matching ASM compiler's hostLabel) + com.github.javaparser.ast.stmt.SwitchEntry hostEntry = null; + if (functionImports > 0) { + hostEntry = new com.github.javaparser.ast.stmt.SwitchEntry(); + BlockStmt hostBody = new BlockStmt(); + // Inline callHostFunction: instance.imports().function(funcId).handle().apply(instance, + // args) + MethodCallExpr importsCall = new MethodCallExpr(); + importsCall.setScope(new NameExpr("instance")); + importsCall.setName("imports"); + MethodCallExpr functionCall = new MethodCallExpr(); + functionCall.setScope(importsCall); + functionCall.setName("function"); + functionCall.addArgument(new NameExpr("funcId")); + MethodCallExpr handleCall = new MethodCallExpr(); + handleCall.setScope(functionCall); + handleCall.setName("handle"); + MethodCallExpr applyCall = new MethodCallExpr(); + applyCall.setScope(handleCall); + applyCall.setName("apply"); + applyCall.addArgument(new NameExpr("instance")); + applyCall.addArgument(new NameExpr("args")); + hostBody.addStatement(new ReturnStmt(applyCall)); + hostEntry.getStatements().addAll(hostBody.getStatements()); + } + + for (int funcId = 0; funcId < functionTypes.size(); funcId++) { + com.github.javaparser.ast.stmt.SwitchEntry entry = + new com.github.javaparser.ast.stmt.SwitchEntry(); + entry.getLabels().add(new IntegerLiteralExpr(String.valueOf(funcId))); + + BlockStmt body = new BlockStmt(); + + if (funcId < functionImports) { + // Host function - use shared host entry + if (hostEntry != null) { + entry.getStatements().addAll(hostEntry.getStatements()); + } + } else { + // Regular function - call static call_xxx method (matching ASM compiler) + MethodCallExpr callMethodExpr = new MethodCallExpr(); + callMethodExpr.setScope(StaticJavaParser.parseExpression(className)); + callMethodExpr.setName("call_" + funcId); + callMethodExpr.addArgument(new NameExpr("memory")); + callMethodExpr.addArgument(new NameExpr("instance")); + callMethodExpr.addArgument(new NameExpr("args")); + // call_xxx returns long[] directly (already boxed) + body.addStatement(new ReturnStmt(callMethodExpr)); + entry.getStatements().addAll(body.getStatements()); + } + + switchStmt.getEntries().add(entry); + } + + com.github.javaparser.ast.stmt.SwitchEntry defaultEntry = + new com.github.javaparser.ast.stmt.SwitchEntry(); + // Inline throwUnknownFunction: throw new InvalidException("unknown function " + funcId) + MethodCallExpr formatCall = new MethodCallExpr(); + formatCall.setScope(StaticJavaParser.parseExpression("String")); + formatCall.setName("format"); + formatCall.addArgument( + new com.github.javaparser.ast.expr.StringLiteralExpr("unknown function %d")); + formatCall.addArgument(new NameExpr("funcId")); + com.github.javaparser.ast.expr.ObjectCreationExpr exception = + new com.github.javaparser.ast.expr.ObjectCreationExpr(); + exception.setType( + StaticJavaParser.parseClassOrInterfaceType( + "com.dylibso.chicory.wasm.InvalidException")); + exception.addArgument(formatCall); + defaultEntry.getStatements().add(new ThrowStmt(exception)); + switchStmt.getEntries().add(defaultEntry); + + // Wrap in try-catch for StackOverflowError (matching ASM compiler's WasmMachine.call) + com.github.javaparser.ast.stmt.TryStmt tryStmt = + new com.github.javaparser.ast.stmt.TryStmt(); + BlockStmt tryBlock = new BlockStmt(); + tryBlock.addStatement(switchStmt); + tryStmt.setTryBlock(tryBlock); + + com.github.javaparser.ast.stmt.CatchClause catchClause = + new com.github.javaparser.ast.stmt.CatchClause(); + catchClause.setParameter( + new com.github.javaparser.ast.body.Parameter( + StaticJavaParser.parseClassOrInterfaceType("StackOverflowError"), "e")); + BlockStmt catchBlock = new BlockStmt(); + catchBlock.addStatement( + StaticJavaParser.parseStatement( + "throw new com.dylibso.chicory.wasm.ChicoryException(" + + "\"call stack exhausted\", e);")); + catchClause.setBody(catchBlock); + tryStmt.getCatchClauses().add(catchClause); + + callBody.addStatement(tryStmt); + } + + /** + * Generate a host function method that delegates to instance.callHostFunction(). + */ + private static void generateHostFunctionMethod( + ClassOrInterfaceDeclaration clazz, int funcId, FunctionType functionType) { + + // Host functions are public static, matching ASM compiler + MethodDeclaration method = + clazz.addMethod("func_" + funcId, Modifier.Keyword.PUBLIC, Modifier.Keyword.STATIC) + .setType(new ArrayType(PrimitiveType.longType())); + + // Add individual typed parameters + for (int i = 0; i < functionType.params().size(); i++) { + ValType paramType = functionType.params().get(i); + method.addParameter( + SourceCompilerUtil.javaParserType(SourceCompilerUtil.jvmType(paramType)), + "arg" + i); + } + + // Add Memory and Instance parameters + method.addParameter( + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Memory"), + "memory"); + method.addParameter( + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Instance"), + "instance"); + + BlockStmt block = new BlockStmt(); + method.setBody(block); + + // Box arguments into long[] + block.addStatement( + StaticJavaParser.parseStatement( + "long[] boxedArgs = new long[" + functionType.params().size() + "];")); + for (int i = 0; i < functionType.params().size(); i++) { + ValType paramType = functionType.params().get(i); + String boxExpr = SourceCompilerUtil.boxJvmToLong("arg" + i, paramType); + block.addStatement( + StaticJavaParser.parseStatement("boxedArgs[" + i + "] = " + boxExpr + ";")); + } + + // Call instance's host function handler + block.addStatement( + StaticJavaParser.parseStatement( + "var imprt = instance.imports().function(" + funcId + ");")); + block.addStatement( + StaticJavaParser.parseStatement( + "return imprt.handle().apply(instance, boxedArgs);")); + } + + private static void generateFunctionMethod( + ClassOrInterfaceDeclaration clazz, + int funcId, + FunctionType functionType, + List instructions, + FunctionBody body, + List allFunctionTypes, + FunctionType[] typeSectionTypes, + List globalTypes) { + + // Method signature: public static func_xxx( argN..., Memory memory, + // Instance instance) + // Mirrors ASM compiler: func_xxx is public static with individual typed parameters + Memory + // + Instance + MethodDeclaration method = + clazz.addMethod("func_" + funcId, Modifier.Keyword.PUBLIC, Modifier.Keyword.STATIC); + + // Set return type based on function type + Class returnType = SourceCompilerUtil.jvmReturnType(functionType); + if (returnType == void.class) { + method.setType(StaticJavaParser.parseType("void")); + } else if (returnType == long[].class) { + method.setType(new ArrayType(PrimitiveType.longType())); + } else { + method.setType(SourceCompilerUtil.javaParserType(returnType)); + } + + // Add individual typed parameters + List localVarNames = new ArrayList<>(); + List localVarTypes = new ArrayList<>(); + for (int i = 0; i < functionType.params().size(); i++) { + ValType paramType = functionType.params().get(i); + String paramName = "arg" + i; + localVarNames.add(paramName); + localVarTypes.add(paramType); + method.addParameter( + SourceCompilerUtil.javaParserType(SourceCompilerUtil.jvmType(paramType)), + paramName); + } + + // Add Memory and Instance parameters + method.addParameter( + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Memory"), + "memory"); + method.addParameter( + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Instance"), + "instance"); + + BlockStmt block = new BlockStmt(); + method.setBody(block); + + // Initialize WASM local variables to default values (mirrors ASM compiler) + for (int i = functionType.params().size(); + i < functionType.params().size() + body.localTypes().size(); + i++) { + ValType localType = body.localTypes().get(i - functionType.params().size()); + String varName = "local" + i; + localVarNames.add(varName); + localVarTypes.add(localType); + String defaultValue = SourceCompilerUtil.defaultValue(localType); + block.addStatement( + StaticJavaParser.parseStatement( + SourceCompilerUtil.javaTypeName(localType) + + " " + + varName + + " = " + + defaultValue + + ";")); + } + + // Scope tracking for structured control flow + Deque scopeStack = new ArrayDeque<>(); + + // Insertion position for result var declarations (after locals, before code) + int[] resultVarInsertPos = {block.getStatements().size()}; + + // Stack of expressions - represents the Java operand stack + Deque stack = new ArrayDeque<>(); + + // Counter for generating unique call variable names (callArgs_0, callResult_0, ...) + int[] callIdx = {0}; + + // Counter for generating unique snapshot variable names (_snap_0, _snap_1, ...) + int[] snapIdx = {0}; + + // Emit instructions using structured control flow + for (CompilerInstruction ins : instructions) { + BlockStmt currentBlock = scopeStack.isEmpty() ? block : scopeStack.peek().block; + CompilerOpCode op = ins.opcode(); + + // Skip non-scope instructions if current block is already terminated + if (isBlockTerminated(currentBlock) + && op != CompilerOpCode.SCOPE_EXIT + && op != CompilerOpCode.ELSE_ENTER) { + // Still need to maintain expression stack for scope tracking + if (op == CompilerOpCode.BLOCK_ENTER + || op == CompilerOpCode.LOOP_ENTER + || op == CompilerOpCode.IF_ENTER) { + // Push a dummy scope so SCOPE_EXIT can pop it + scopeStack.push( + new EmitterScope( + (int) ins.operand(0), + "dead", + new BlockStmt(), + null, + null, + new ArrayList<>(stack))); + } + continue; + } + + switch (op) { + case BLOCK_ENTER: + { + int label = (int) ins.operand(0); + int resultCount = ins.operandCount() - 1; + String[] resultVars = + declareResultVars( + resultCount, label, ins, block, resultVarInsertPos); + + BlockStmt innerBlock = new BlockStmt(); + LabeledStmt labeledStmt = new LabeledStmt(); + labeledStmt.setLabel(new SimpleName("label_" + label)); + labeledStmt.setStatement(innerBlock); + currentBlock.addStatement(labeledStmt); + scopeStack.push( + new EmitterScope( + label, + "block", + innerBlock, + resultVars, + null, + new ArrayList<>(stack))); + break; + } + + case LOOP_ENTER: + { + int label = (int) ins.operand(0); + int paramCount = (int) ins.operand(1); + int returnCount = ins.operandCount() - 2 - paramCount; + + // Declare loop result variables (before the while loop) + String[] resultVars = null; + if (returnCount > 0) { + resultVars = new String[returnCount]; + for (int r = 0; r < returnCount; r++) { + long typeId = ins.operand(2 + paramCount + r); + String varName = "block_" + label + "_result_" + r; + resultVars[r] = varName; + String defaultValue = defaultValueForId(typeId); + int insertIdx = resultVarInsertPos[0]++; + block.getStatements() + .add( + insertIdx, + StaticJavaParser.parseStatement( + javaTypeNameForId(typeId) + + " " + + varName + + " = " + + defaultValue + + ";")); + } + } + + // Declare loop param variables and assign initial values + String[] loopParamVars = null; + if (paramCount > 0) { + loopParamVars = new String[paramCount]; + // Pop initial values (right-to-left) + com.github.javaparser.ast.expr.Expression[] initVals = + new com.github.javaparser.ast.expr.Expression[paramCount]; + for (int p = paramCount - 1; p >= 0; p--) { + initVals[p] = stack.pop(); + } + // Declare and assign + for (int p = 0; p < paramCount; p++) { + long typeId = ins.operand(2 + p); + String varName = "loop_" + label + "_param_" + p; + loopParamVars[p] = varName; + currentBlock.addStatement( + StaticJavaParser.parseStatement( + javaTypeNameForId(typeId) + + " " + + varName + + " = " + + initVals[p] + + ";")); + } + // Push param variable references onto expression stack + for (String pv : loopParamVars) { + stack.push(new NameExpr(pv)); + } + } + + BlockStmt loopBody = new BlockStmt(); + WhileStmt whileStmt = new WhileStmt(new BooleanLiteralExpr(true), loopBody); + LabeledStmt labeledStmt = new LabeledStmt(); + labeledStmt.setLabel(new SimpleName("label_" + label)); + labeledStmt.setStatement(whileStmt); + currentBlock.addStatement(labeledStmt); + scopeStack.push( + new EmitterScope( + label, + "loop", + loopBody, + resultVars, + null, + loopParamVars, + new ArrayList<>(stack))); + break; + } + + case IF_ENTER: + { + int label = (int) ins.operand(0); + int paramCount = (int) ins.operand(1); + int returnCount = ins.operandCount() - 2 - paramCount; + com.github.javaparser.ast.expr.Expression condition = stack.pop(); + + // Declare result variables + String[] resultVars = null; + if (returnCount > 0) { + resultVars = new String[returnCount]; + for (int r = 0; r < returnCount; r++) { + long typeId = ins.operand(2 + paramCount + r); + String varName = "block_" + label + "_result_" + r; + resultVars[r] = varName; + int insertIdx = resultVarInsertPos[0]++; + block.getStatements() + .add( + insertIdx, + StaticJavaParser.parseStatement( + javaTypeNameForId(typeId) + + " " + + varName + + " = " + + defaultValueForId(typeId) + + ";")); + } + } + + // Materialize if-params to variables so both branches + // can access them (matching ASM compiler's stack frame save/restore) + String[] ifParamVars = null; + if (paramCount > 0) { + ifParamVars = new String[paramCount]; + com.github.javaparser.ast.expr.Expression[] initVals = + new com.github.javaparser.ast.expr.Expression[paramCount]; + for (int p = paramCount - 1; p >= 0; p--) { + initVals[p] = stack.pop(); + } + for (int p = 0; p < paramCount; p++) { + long typeId = ins.operand(2 + p); + String varName = "if_" + label + "_param_" + p; + ifParamVars[p] = varName; + // Declare with default value at function level + int insertIdx = resultVarInsertPos[0]++; + block.getStatements() + .add( + insertIdx, + StaticJavaParser.parseStatement( + javaTypeNameForId(typeId) + + " " + + varName + + " = " + + defaultValueForId(typeId) + + ";")); + // Assign actual value inline (before the if statement) + currentBlock.addStatement( + StaticJavaParser.parseStatement( + varName + " = " + initVals[p] + ";")); + } + // Push param variable references for the then branch + for (String pv : ifParamVars) { + stack.push(new NameExpr(pv)); + } + } + + BlockStmt thenBlock = new BlockStmt(); + BinaryExpr condExpr = + new BinaryExpr( + condition, + new IntegerLiteralExpr("0"), + BinaryExpr.Operator.NOT_EQUALS); + IfStmt ifStmt = new IfStmt(condExpr, thenBlock, null); + // Wrap in a labeled block so br can target the if label + BlockStmt ifWrapper = new BlockStmt(); + ifWrapper.addStatement(ifStmt); + LabeledStmt labeledStmt = new LabeledStmt(); + labeledStmt.setLabel(new SimpleName("label_" + label)); + labeledStmt.setStatement(ifWrapper); + currentBlock.addStatement(labeledStmt); + scopeStack.push( + new EmitterScope( + label, + "if", + thenBlock, + resultVars, + ifStmt, + ifParamVars, + new ArrayList<>(stack))); + break; + } + + case ELSE_ENTER: + { + EmitterScope ifScope = scopeStack.pop(); + // Assign then-branch results to result variables + assignResults(ifScope.resultVarNames, ifScope.block, stack); + // Create else block + BlockStmt elseBlock = new BlockStmt(); + ifScope.ifStmt.setElseStmt(elseBlock); + // Restore param variable references for the else branch + if (ifScope.paramVarNames != null) { + for (String pv : ifScope.paramVarNames) { + stack.push(new NameExpr(pv)); + } + } + scopeStack.push( + new EmitterScope( + ifScope.label, + "else", + elseBlock, + ifScope.resultVarNames, + ifScope.ifStmt, + ifScope.savedStack)); + break; + } + + case SCOPE_EXIT: + { + EmitterScope scope = scopeStack.pop(); + boolean terminated = isBlockTerminated(scope.block); + + // Assign results if present (skip if block already terminated) + if (!terminated) { + assignResults(scope.resultVarNames, scope.block, stack); + } else { + // Restore expression stack to scope entry state. + // Terminated blocks may contain DROP_KEEP + BREAK that + // consume values belonging to outer scopes. Since the + // expression stack is shared across all code paths, we + // must undo those modifications for the non-taken paths. + stack.clear(); + for (int s = scope.savedStack.size() - 1; s >= 0; s--) { + stack.push(scope.savedStack.get(s)); + } + } + + // For "if" without else with params: synthesize else branch + // that passes params through to results (WASM semantics) + if (scope.type.equals("if") + && scope.paramVarNames != null + && scope.resultVarNames != null + && scope.ifStmt != null + && !scope.ifStmt.hasElseBranch()) { + BlockStmt elseBlock = new BlockStmt(); + int count = + Math.min( + scope.paramVarNames.length, + scope.resultVarNames.length); + for (int i = 0; i < count; i++) { + elseBlock.addStatement( + new ExpressionStmt( + new AssignExpr( + new NameExpr(scope.resultVarNames[i]), + new NameExpr(scope.paramVarNames[i]), + AssignExpr.Operator.ASSIGN))); + } + scope.ifStmt.setElseStmt(elseBlock); + } + + // For loops, add break to exit the while(true) at end of body + if (scope.type.equals("loop") && !terminated) { + scope.block.addStatement(new BreakStmt()); + } + + // Only push result vars if the scope isn't terminal for the parent. + // If terminated by break-to-own-label: not terminal, push results. + // If terminated by break-to-outer/throw/return: terminal, skip. + // For if/else: both branches must be terminal for the whole + // if-else to be terminal. + boolean terminalForParent; + if (scope.type.equals("else") && scope.ifStmt != null) { + // Both then and else branches must terminate + boolean thenTerminated = + isBlockTerminated((BlockStmt) scope.ifStmt.getThenStmt()); + boolean elseTerminated = terminated; + terminalForParent = + thenTerminated + && elseTerminated + && !containsBreakTo( + scope.ifStmt, "label_" + scope.label, false); + } else if (scope.type.equals("if")) { + // if-without-else: never terminal (fall-through on false) + terminalForParent = false; + } else { + terminalForParent = + terminated + && !containsBreakTo( + scope.block, + "label_" + scope.label, + scope.type.equals("loop")); + } + if (scope.resultVarNames != null && !terminalForParent) { + for (String resultVar : scope.resultVarNames) { + stack.push(new NameExpr(resultVar)); + } + } + break; + } + + case BREAK: + { + int label = (int) ins.operand(0); + EmitterScope targetScope = findScope(scopeStack, label); + if (targetScope == null) { + // Target is function scope: emit return + RETURN(ins, currentBlock, stack, functionType); + } else { + assignResults(targetScope.resultVarNames, currentBlock, stack); + BreakStmt breakStmt = new BreakStmt(); + breakStmt.setLabel(new SimpleName("label_" + label)); + currentBlock.addStatement(breakStmt); + } + break; + } + + case BREAK_IF: + { + int label = (int) ins.operand(0); + com.github.javaparser.ast.expr.Expression condition = stack.pop(); + EmitterScope targetScope = findScope(scopeStack, label); + BlockStmt thenBlock = new BlockStmt(); + + // Determine how many values to keep for the branch-taken path + int keep = 0; + if (targetScope != null && targetScope.resultVarNames != null) { + keep = targetScope.resultVarNames.length; + } else if (targetScope == null) { + keep = functionType.returns().size(); + } + + // Peek at top 'keep' values from stack without modifying it + // These are the values that would be the block/function results + com.github.javaparser.ast.expr.Expression[] keepVals = + new com.github.javaparser.ast.expr.Expression[keep]; + var stackIter = stack.iterator(); + for (int i = 0; i < keep && stackIter.hasNext(); i++) { + keepVals[i] = stackIter.next(); + } + + if (targetScope == null) { + // Target is function scope: emit conditional return + Class retType = SourceCompilerUtil.jvmReturnType(functionType); + if (retType == void.class) { + thenBlock.addStatement(StaticJavaParser.parseStatement("return;")); + } else { + // Use a copy of keepVals as a stack for RETURN + Deque retStack = + new ArrayDeque<>(); + for (int i = keep - 1; i >= 0; i--) { + retStack.push(keepVals[i]); + } + RETURN( + new CompilerInstruction(CompilerOpCode.RETURN, new long[0]), + thenBlock, + retStack, + functionType); + } + } else if (targetScope.resultVarNames != null) { + // Assign result vars in thenBlock using peeked values + for (int r = 0; r < keep; r++) { + thenBlock.addStatement( + new ExpressionStmt( + new AssignExpr( + new NameExpr(targetScope.resultVarNames[r]), + keepVals[r], + AssignExpr.Operator.ASSIGN))); + } + BreakStmt breakStmt = new BreakStmt(); + breakStmt.setLabel(new SimpleName("label_" + label)); + thenBlock.addStatement(breakStmt); + } else { + BreakStmt breakStmt = new BreakStmt(); + breakStmt.setLabel(new SimpleName("label_" + label)); + thenBlock.addStatement(breakStmt); + } + + BinaryExpr condExpr = + new BinaryExpr( + condition, + new IntegerLiteralExpr("0"), + BinaryExpr.Operator.NOT_EQUALS); + currentBlock.addStatement(new IfStmt(condExpr, thenBlock, null)); + // Stack unchanged for fall-through path + break; + } + + case CONTINUE: + { + int label = (int) ins.operand(0); + EmitterScope loopScope = findScope(scopeStack, label); + assignLoopParams(loopScope, currentBlock, stack); + emitInterruptCheck(currentBlock); + ContinueStmt continueStmt = new ContinueStmt(); + continueStmt.setLabel(new SimpleName("label_" + label)); + currentBlock.addStatement(continueStmt); + break; + } + + case CONTINUE_IF: + { + int label = (int) ins.operand(0); + com.github.javaparser.ast.expr.Expression condition = stack.pop(); + BlockStmt thenBlock = new BlockStmt(); + + EmitterScope loopScope = findScope(scopeStack, label); + // Peek at loop param values from stack (don't modify stack) + // Iterator returns top-to-bottom; params are bottom-to-top + // so reverse the order: paramVals[0] = bottom = param_0 + int paramCount = + (loopScope != null && loopScope.paramVarNames != null) + ? loopScope.paramVarNames.length + : 0; + com.github.javaparser.ast.expr.Expression[] paramVals = + new com.github.javaparser.ast.expr.Expression[paramCount]; + var contIter = stack.iterator(); + for (int i = 0; i < paramCount && contIter.hasNext(); i++) { + paramVals[paramCount - 1 - i] = contIter.next(); + } + // Use temp vars to avoid the swap problem when + // param expressions reference other param variables + if (paramCount > 0) { + assignParamsWithTemps(loopScope.paramVarNames, paramVals, thenBlock); + } + emitInterruptCheck(thenBlock); + ContinueStmt continueStmt = new ContinueStmt(); + continueStmt.setLabel(new SimpleName("label_" + label)); + thenBlock.addStatement(continueStmt); + + BinaryExpr condExpr = + new BinaryExpr( + condition, + new IntegerLiteralExpr("0"), + BinaryExpr.Operator.NOT_EQUALS); + currentBlock.addStatement(new IfStmt(condExpr, thenBlock, null)); + // Stack unchanged for fall-through path + break; + } + + case TRAP: + currentBlock.addStatement( + StaticJavaParser.parseStatement( + "throw new" + + " com.dylibso.chicory.runtime.TrapException(" + + "\"Trapped on unreachable instruction\");")); + break; + + case RETURN: + RETURN(ins, currentBlock, stack, functionType); + break; + + case DROP: + DROP(ins, currentBlock, stack); + break; + + case DROP_KEEP: + DROP_KEEP(ins, stack); + break; + + case SWITCH: + { + // BR_TABLE: operands are [label0, isLoop0, label1, isLoop1, ...] + // Entries 0..N-2 are case labels, entry N-1 is the default + com.github.javaparser.ast.expr.Expression selector = stack.pop(); + int entryCount = ins.operandCount() / 2; + int defaultIdx = entryCount - 1; + + com.github.javaparser.ast.stmt.SwitchStmt switchStmt = + new com.github.javaparser.ast.stmt.SwitchStmt(); + switchStmt.setSelector(selector); + + for (int i = 0; i < entryCount; i++) { + int targetLabel = (int) ins.operand(i * 2); + boolean isLoop = ins.operand(i * 2 + 1) != 0; + + com.github.javaparser.ast.stmt.SwitchEntry entry = + new com.github.javaparser.ast.stmt.SwitchEntry(); + if (i < defaultIdx) { + entry.getLabels().add(new IntegerLiteralExpr(String.valueOf(i))); + } + // Wrap in a block to scope local variables per case + BlockStmt caseBlock = new BlockStmt(); + + if (isLoop) { + EmitterScope loopScope = findScope(scopeStack, targetLabel); + int paramCount = + (loopScope != null && loopScope.paramVarNames != null) + ? loopScope.paramVarNames.length + : 0; + if (paramCount > 0) { + com.github.javaparser.ast.expr.Expression[] paramVals = + new com.github.javaparser.ast.expr.Expression + [paramCount]; + var pIter = stack.iterator(); + for (int p = 0; p < paramCount && pIter.hasNext(); p++) { + paramVals[paramCount - 1 - p] = pIter.next(); + } + assignParamsWithTemps( + loopScope.paramVarNames, paramVals, caseBlock); + } + emitInterruptCheck(caseBlock); + ContinueStmt continueStmt = new ContinueStmt(); + continueStmt.setLabel(new SimpleName("label_" + targetLabel)); + caseBlock.addStatement(continueStmt); + } else { + EmitterScope targetScope = findScope(scopeStack, targetLabel); + if (targetScope == null) { + // Target is function scope: emit return + int keep = functionType.returns().size(); + Deque retStack = + new ArrayDeque<>(); + var retIter = stack.iterator(); + com.github.javaparser.ast.expr.Expression[] keepVals = + new com.github.javaparser.ast.expr.Expression[keep]; + for (int r = 0; r < keep && retIter.hasNext(); r++) { + keepVals[r] = retIter.next(); + } + for (int r = keep - 1; r >= 0; r--) { + retStack.push(keepVals[r]); + } + RETURN( + new CompilerInstruction( + CompilerOpCode.RETURN, new long[0]), + caseBlock, + retStack, + functionType); + } else { + if (targetScope.resultVarNames != null) { + int keep = targetScope.resultVarNames.length; + var sIter = stack.iterator(); + for (int r = 0; r < keep && sIter.hasNext(); r++) { + com.github.javaparser.ast.expr.Expression val = + sIter.next(); + caseBlock.addStatement( + new ExpressionStmt( + new AssignExpr( + new NameExpr( + targetScope + .resultVarNames[ + r]), + val, + AssignExpr.Operator.ASSIGN))); + } + } + BreakStmt breakStmt = new BreakStmt(); + breakStmt.setLabel(new SimpleName("label_" + targetLabel)); + caseBlock.addStatement(breakStmt); + } + } + + entry.getStatements().add(caseBlock); + switchStmt.getEntries().add(entry); + } + + currentBlock.addStatement(switchStmt); + break; + } + + default: + emitInstruction( + ins, + currentBlock, + block, + stack, + localVarNames, + localVarTypes, + functionType, + allFunctionTypes, + typeSectionTypes, + globalTypes, + callIdx, + snapIdx); + break; + } + } + + // Emit implicit return if function body doesn't end with a return/throw + // This handles cases where the outermost block exits via break and + // the result values are on the expression stack + if (!isBlockTerminated(block) && !stack.isEmpty()) { + RETURN( + new CompilerInstruction(CompilerOpCode.RETURN, new long[0]), + block, + stack, + functionType); + } + } + + /** Declare result variables for a block/if scope. Returns null if no results. */ + private static String[] declareResultVars( + int resultCount, int label, CompilerInstruction ins, BlockStmt block, int[] insertPos) { + if (resultCount <= 0) { + return null; + } + String[] resultVars = new String[resultCount]; + for (int r = 0; r < resultCount; r++) { + long typeId = ins.operand(r + 1); + String varName = "block_" + label + "_result_" + r; + resultVars[r] = varName; + block.getStatements() + .add( + insertPos[0]++, + StaticJavaParser.parseStatement( + javaTypeNameForId(typeId) + + " " + + varName + + " = " + + defaultValueForId(typeId) + + ";")); + } + return resultVars; + } + + /** Assign top-of-stack values to result variables (if stack has enough values). */ + private static void assignResults( + String[] resultVarNames, + BlockStmt block, + Deque stack) { + if (resultVarNames == null || resultVarNames.length == 0) { + return; + } + for (int r = resultVarNames.length - 1; r >= 0; r--) { + if (!stack.isEmpty()) { + com.github.javaparser.ast.expr.Expression val = stack.pop(); + block.addStatement( + new ExpressionStmt( + new AssignExpr( + new NameExpr(resultVarNames[r]), + val, + AssignExpr.Operator.ASSIGN))); + } + } + } + + /** Assign loop param values from the expression stack (for unconditional CONTINUE). */ + private static void assignLoopParams( + EmitterScope loopScope, + BlockStmt block, + Deque stack) { + if (loopScope == null || loopScope.paramVarNames == null) { + return; + } + int paramCount = loopScope.paramVarNames.length; + // Pop values right-to-left, then assign left-to-right + com.github.javaparser.ast.expr.Expression[] vals = + new com.github.javaparser.ast.expr.Expression[paramCount]; + for (int p = paramCount - 1; p >= 0; p--) { + if (!stack.isEmpty()) { + vals[p] = stack.pop(); + } + } + assignParamsWithTemps(loopScope.paramVarNames, vals, block); + } + + /** + * Assign values to param/result variables using temp variables when needed + * to avoid the "swap problem" where sequential assignments read + * already-modified values. + */ + private static void assignParamsWithTemps( + String[] varNames, com.github.javaparser.ast.expr.Expression[] vals, BlockStmt block) { + int count = varNames.length; + if (count <= 1) { + // Single param: no swap problem possible + if (count == 1 && vals[0] != null) { + block.addStatement( + new ExpressionStmt( + new AssignExpr( + new NameExpr(varNames[0]), + vals[0], + AssignExpr.Operator.ASSIGN))); + } + return; + } + // Multiple params: use temps to capture all values first + String[] tempNames = new String[count]; + for (int p = 0; p < count; p++) { + if (vals[p] != null) { + tempNames[p] = varNames[p] + "_tmp"; + block.addStatement( + StaticJavaParser.parseStatement( + "var " + tempNames[p] + " = " + vals[p] + ";")); + } + } + for (int p = 0; p < count; p++) { + if (tempNames[p] != null) { + block.addStatement( + new ExpressionStmt( + new AssignExpr( + new NameExpr(varNames[p]), + new NameExpr(tempNames[p]), + AssignExpr.Operator.ASSIGN))); + } + } + } + + /** Check if a block's last statement is terminal (throw/return/break/continue). */ + private static boolean isBlockTerminated(BlockStmt block) { + var stmts = block.getStatements(); + if (stmts.isEmpty()) { + return false; + } + var last = stmts.get(stmts.size() - 1); + if (last instanceof ThrowStmt + || last instanceof ReturnStmt + || last instanceof BreakStmt + || last instanceof ContinueStmt) { + return true; + } + if (last instanceof LabeledStmt) { + return isLabeledBlockTerminal((LabeledStmt) last); + } + if (last instanceof com.github.javaparser.ast.stmt.SwitchStmt) { + return isSwitchTerminal((com.github.javaparser.ast.stmt.SwitchStmt) last); + } + return false; + } + + /** + * A switch statement is terminal if every entry (case) ends with abrupt completion + * (break to outer label, continue, return, or throw) and has a default case. + */ + private static boolean isSwitchTerminal(com.github.javaparser.ast.stmt.SwitchStmt sw) { + boolean hasDefault = false; + for (var entry : sw.getEntries()) { + if (entry.getLabels().isEmpty()) { + hasDefault = true; + } + var entryStmts = entry.getStatements(); + if (entryStmts.isEmpty()) { + return false; + } + var lastStmt = entryStmts.get(entryStmts.size() - 1); + // Each case body is wrapped in a BlockStmt + if (lastStmt instanceof BlockStmt) { + if (!isBlockTerminated((BlockStmt) lastStmt)) { + return false; + } + } else if (!(lastStmt instanceof BreakStmt + || lastStmt instanceof ContinueStmt + || lastStmt instanceof ReturnStmt + || lastStmt instanceof ThrowStmt)) { + return false; + } + } + return hasDefault; + } + + /** + * A labeled block terminates the enclosing scope if: + * 1. Its inner block ends in throw/return (recursively), AND + * 2. No break targets this label (which would exit to the enclosing scope) + */ + private static boolean isLabeledBlockTerminal(LabeledStmt labeled) { + var inner = labeled.getStatement(); + BlockStmt body; + if (inner instanceof BlockStmt) { + body = (BlockStmt) inner; + } else if (inner instanceof WhileStmt) { + var whileBody = ((WhileStmt) inner).getBody(); + if (!(whileBody instanceof BlockStmt)) { + return false; + } + body = (BlockStmt) whileBody; + } else { + return false; + } + if (!endsWithAbruptCompletion(body)) { + return false; + } + String labelName = labeled.getLabel().asString(); + boolean inLoop = !(labeled.getStatement() instanceof BlockStmt); + return !containsBreakTo(body, labelName, inLoop); + } + + private static boolean endsWithAbruptCompletion(BlockStmt block) { + var stmts = block.getStatements(); + if (stmts.isEmpty()) { + return false; + } + var last = stmts.get(stmts.size() - 1); + if (last instanceof ThrowStmt + || last instanceof ReturnStmt + || last instanceof BreakStmt + || last instanceof ContinueStmt) { + return true; + } + if (last instanceof LabeledStmt) { + return isLabeledBlockTerminal((LabeledStmt) last); + } + if (last instanceof com.github.javaparser.ast.stmt.SwitchStmt) { + return isSwitchTerminal((com.github.javaparser.ast.stmt.SwitchStmt) last); + } + return false; + } + + private static boolean containsBreakTo( + com.github.javaparser.ast.Node node, String label, boolean inLoop) { + if (node instanceof BreakStmt) { + var breakLabel = ((BreakStmt) node).getLabel(); + if (breakLabel.isPresent() && breakLabel.get().asString().equals(label)) { + return true; + } + // Bare break inside a while exits the loop → flow continues after the label + if (!breakLabel.isPresent() && inLoop) { + return true; + } + } + for (var child : node.getChildNodes()) { + // Bare breaks inside nested WhileStmts are captured by those loops, + // so reset inLoop when entering a nested while + boolean childInLoop = inLoop && !(child instanceof WhileStmt); + if (containsBreakTo(child, label, childInLoop)) { + return true; + } + } + return false; + } + + /** + * Generate call_xxx bridge method: public static long[] call_xxx(Memory memory, Instance instance, long[] args) + * Mirrors ASM compiler's compileCallFunction method. + */ + private static void generateCallFunctionMethod( + ClassOrInterfaceDeclaration clazz, + String className, + int funcId, + FunctionType functionType) { + MethodDeclaration method = + clazz.addMethod("call_" + funcId, Modifier.Keyword.PUBLIC, Modifier.Keyword.STATIC) + .setType(new ArrayType(PrimitiveType.longType())); + method.addParameter( + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Memory"), + "memory"); + method.addParameter( + StaticJavaParser.parseClassOrInterfaceType("com.dylibso.chicory.runtime.Instance"), + "instance"); + method.addParameter(new ArrayType(PrimitiveType.longType()), "args"); + + BlockStmt block = new BlockStmt(); + method.setBody(block); + + // Unbox arguments from long[] + if (SourceCompilerUtil.hasTooManyParameters(functionType)) { + // For functions with too many parameters, pass long[] directly + MethodCallExpr funcCall = new MethodCallExpr(); + funcCall.setScope(StaticJavaParser.parseExpression(className)); + funcCall.setName("func_" + funcId); + funcCall.addArgument(new NameExpr("args")); + funcCall.addArgument(new NameExpr("memory")); + funcCall.addArgument(new NameExpr("instance")); + block.addStatement(new ReturnStmt(funcCall)); + } else { + // Unbox arguments + for (int i = 0; i < functionType.params().size(); i++) { + ValType paramType = functionType.params().get(i); + String unboxExpr = SourceCompilerUtil.unboxLongToJvm("args[" + i + "]", paramType); + String paramName = "arg" + i; + block.addStatement( + StaticJavaParser.parseStatement( + SourceCompilerUtil.javaTypeName(paramType) + + " " + + paramName + + " = " + + unboxExpr + + ";")); + } + + // Call func_xxx + MethodCallExpr funcCall = new MethodCallExpr(); + funcCall.setScope(StaticJavaParser.parseExpression(className)); + funcCall.setName("func_" + funcId); + for (int i = 0; i < functionType.params().size(); i++) { + funcCall.addArgument(new NameExpr("arg" + i)); + } + funcCall.addArgument(new NameExpr("memory")); + funcCall.addArgument(new NameExpr("instance")); + + // Box result into long[] + Class returnType = SourceCompilerUtil.jvmReturnType(functionType); + if (returnType == void.class) { + block.addStatement(new ExpressionStmt(funcCall)); + block.addStatement(StaticJavaParser.parseStatement("return null;")); + } else if (returnType == long[].class) { + block.addStatement(new ReturnStmt(funcCall)); + } else { + String varName = "result"; + String varDecl = + SourceCompilerUtil.javaTypeName(returnType) + + " " + + varName + + " = " + + funcCall.toString() + + ";"; + block.addStatement(StaticJavaParser.parseStatement(varDecl)); + block.addStatement(StaticJavaParser.parseStatement("long[] out = new long[1];")); + String boxExpr = + SourceCompilerUtil.boxJvmToLong(varName, functionType.returns().get(0)); + block.addStatement(StaticJavaParser.parseStatement("out[0] = " + boxExpr + ";")); + block.addStatement(StaticJavaParser.parseStatement("return out;")); + } + } + } + + /** + * Emit instruction - mirrors the ASM compiler's instruction handling. + * Uses a stack of expressions to represent the Java operand stack. + */ + private static void emitInstruction( + CompilerInstruction ins, + BlockStmt block, + BlockStmt funcBlock, + Deque stack, + List localVarNames, + List localVarTypes, + FunctionType functionType, + List allFunctionTypes, + FunctionType[] typeSectionTypes, + List globalTypes, + int[] callIdx, + int[] snapIdx) { + CompilerOpCode op = ins.opcode(); + switch (op) { + case I32_CONST: + I32_CONST(ins, stack); + break; + case I32_ADD: + I32_ADD(ins, stack); + break; + case I32_SUB: + I32_SUB(ins, stack); + break; + case I32_MUL: + I32_MUL(ins, stack); + break; + case I32_DIV_S: + I32_DIV_S(ins, stack); + break; + case I32_DIV_U: + I32_DIV_U(ins, stack); + break; + case I32_REM_S: + I32_REM_S(ins, stack); + break; + case I32_REM_U: + I32_REM_U(ins, stack); + break; + case I32_AND: + I32_AND(ins, stack); + break; + case I32_OR: + I32_OR(ins, stack); + break; + case I32_XOR: + I32_XOR(ins, stack); + break; + case I32_SHL: + I32_SHL(ins, stack); + break; + case I32_SHR_S: + I32_SHR_S(ins, stack); + break; + case I32_SHR_U: + I32_SHR_U(ins, stack); + break; + case I32_ROTL: + I32_ROTL(ins, stack); + break; + case I32_ROTR: + I32_ROTR(ins, stack); + break; + case I32_CLZ: + I32_CLZ(ins, stack); + break; + case I32_CTZ: + I32_CTZ(ins, stack); + break; + case I32_POPCNT: + I32_POPCNT(ins, stack); + break; + case I32_EXTEND_8_S: + I32_EXTEND_8_S(ins, stack); + break; + case I32_EXTEND_16_S: + I32_EXTEND_16_S(ins, stack); + break; + case I32_WRAP_I64: + I32_WRAP_I64(ins, stack); + break; + case I32_TRUNC_F32_S: + I32_TRUNC_F32_S(ins, stack); + break; + case I32_TRUNC_F32_U: + I32_TRUNC_F32_U(ins, stack); + break; + case I32_TRUNC_F64_S: + I32_TRUNC_F64_S(ins, stack); + break; + case I32_TRUNC_F64_U: + I32_TRUNC_F64_U(ins, stack); + break; + case I32_TRUNC_SAT_F32_S: + I32_TRUNC_SAT_F32_S(ins, stack); + break; + case I32_TRUNC_SAT_F32_U: + I32_TRUNC_SAT_F32_U(ins, stack); + break; + case I32_TRUNC_SAT_F64_S: + I32_TRUNC_SAT_F64_S(ins, stack); + break; + case I32_TRUNC_SAT_F64_U: + I32_TRUNC_SAT_F64_U(ins, stack); + break; + case I32_EQZ: + I32_EQZ(ins, stack); + break; + case I32_EQ: + I32_EQ(ins, stack); + break; + case I32_NE: + I32_NE(ins, stack); + break; + case I32_LT_S: + I32_LT_S(ins, stack); + break; + case I32_LT_U: + I32_LT_U(ins, stack); + break; + case I32_GT_S: + I32_GT_S(ins, stack); + break; + case I32_GT_U: + I32_GT_U(ins, stack); + break; + case I32_LE_S: + I32_LE_S(ins, stack); + break; + case I32_LE_U: + I32_LE_U(ins, stack); + break; + case I32_GE_S: + I32_GE_S(ins, stack); + break; + case I32_GE_U: + I32_GE_U(ins, stack); + break; + case I64_ADD: + I64_ADD(ins, stack); + break; + case I64_SUB: + I64_SUB(ins, stack); + break; + case I64_MUL: + I64_MUL(ins, stack); + break; + case I64_DIV_S: + I64_DIV_S(ins, stack); + break; + case I64_DIV_U: + I64_DIV_U(ins, stack); + break; + case I64_REM_S: + I64_REM_S(ins, stack); + break; + case I64_REM_U: + I64_REM_U(ins, stack); + break; + case I64_AND: + I64_AND(ins, stack); + break; + case I64_OR: + I64_OR(ins, stack); + break; + case I64_XOR: + I64_XOR(ins, stack); + break; + case I64_SHL: + I64_SHL(ins, stack); + break; + case I64_SHR_S: + I64_SHR_S(ins, stack); + break; + case I64_SHR_U: + I64_SHR_U(ins, stack); + break; + case I64_ROTL: + I64_ROTL(ins, stack); + break; + case I64_ROTR: + I64_ROTR(ins, stack); + break; + case I64_CLZ: + I64_CLZ(ins, stack); + break; + case I64_CTZ: + I64_CTZ(ins, stack); + break; + case I64_POPCNT: + I64_POPCNT(ins, stack); + break; + case I64_EQZ: + I64_EQZ(ins, stack); + break; + case I64_EQ: + I64_EQ(ins, stack); + break; + case I64_NE: + I64_NE(ins, stack); + break; + case I64_LT_S: + I64_LT_S(ins, stack); + break; + case I64_LT_U: + I64_LT_U(ins, stack); + break; + case I64_GT_S: + I64_GT_S(ins, stack); + break; + case I64_GT_U: + I64_GT_U(ins, stack); + break; + case I64_LE_S: + I64_LE_S(ins, stack); + break; + case I64_LE_U: + I64_LE_U(ins, stack); + break; + case I64_GE_S: + I64_GE_S(ins, stack); + break; + case I64_GE_U: + I64_GE_U(ins, stack); + break; + case I64_EXTEND_8_S: + I64_EXTEND_8_S(ins, stack); + break; + case I64_EXTEND_16_S: + I64_EXTEND_16_S(ins, stack); + break; + case I64_EXTEND_32_S: + I64_EXTEND_32_S(ins, stack); + break; + case I64_EXTEND_I32_S: + I64_EXTEND_I32_S(ins, stack); + break; + case I64_EXTEND_I32_U: + I64_EXTEND_I32_U(ins, stack); + break; + case I64_TRUNC_F32_S: + I64_TRUNC_F32_S(ins, stack); + break; + case I64_TRUNC_F32_U: + I64_TRUNC_F32_U(ins, stack); + break; + case I64_TRUNC_F64_S: + I64_TRUNC_F64_S(ins, stack); + break; + case I64_TRUNC_F64_U: + I64_TRUNC_F64_U(ins, stack); + break; + case I64_TRUNC_SAT_F32_S: + I64_TRUNC_SAT_F32_S(ins, stack); + break; + case I64_TRUNC_SAT_F32_U: + I64_TRUNC_SAT_F32_U(ins, stack); + break; + case I64_TRUNC_SAT_F64_S: + I64_TRUNC_SAT_F64_S(ins, stack); + break; + case I64_TRUNC_SAT_F64_U: + I64_TRUNC_SAT_F64_U(ins, stack); + break; + case I64_REINTERPRET_F64: + I64_REINTERPRET_F64(ins, stack); + break; + case LOCAL_GET: + LOCAL_GET(ins, stack, localVarNames); + break; + case LOCAL_SET: + LOCAL_SET(ins, block, funcBlock, stack, localVarNames, localVarTypes, snapIdx); + break; + case LOCAL_TEE: + LOCAL_TEE(ins, block, funcBlock, stack, localVarNames, localVarTypes, snapIdx); + break; + case CALL: + CALL(ins, block, stack, allFunctionTypes, callIdx); + break; + case CALL_INDIRECT: + CALL_INDIRECT(ins, block, stack, typeSectionTypes, callIdx); + break; + case RETURN: + RETURN(ins, block, stack, functionType); + break; + case I32_LOAD: + I32_LOAD(ins, block, stack); + break; + case I32_STORE: + I32_STORE(ins, block, stack); + break; + case I32_LOAD8_S: + I32_LOAD8_S(ins, block, stack); + break; + case I32_LOAD8_U: + I32_LOAD8_U(ins, block, stack); + break; + case I32_LOAD16_S: + I32_LOAD16_S(ins, block, stack); + break; + case I32_LOAD16_U: + I32_LOAD16_U(ins, block, stack); + break; + case I32_STORE8: + I32_STORE8(ins, block, stack); + break; + case I32_STORE16: + I32_STORE16(ins, block, stack); + break; + case I64_CONST: + I64_CONST(ins, stack); + break; + case I64_LOAD: + I64_LOAD(ins, block, stack); + break; + case I64_LOAD8_S: + I64_LOAD8_S(ins, block, stack); + break; + case I64_LOAD8_U: + I64_LOAD8_U(ins, block, stack); + break; + case I64_LOAD16_S: + I64_LOAD16_S(ins, block, stack); + break; + case I64_LOAD16_U: + I64_LOAD16_U(ins, block, stack); + break; + case I64_LOAD32_S: + I64_LOAD32_S(ins, block, stack); + break; + case I64_LOAD32_U: + I64_LOAD32_U(ins, block, stack); + break; + case I64_STORE: + I64_STORE(ins, block, stack); + break; + case I64_STORE8: + I64_STORE8(ins, block, stack); + break; + case I64_STORE16: + I64_STORE16(ins, block, stack); + break; + case I64_STORE32: + I64_STORE32(ins, block, stack); + break; + case F32_NEG: + F32_NEG(ins, stack); + break; + case F32_CONST: + F32_CONST(ins, stack); + break; + case F32_ABS: + F32_ABS(ins, stack); + break; + case F32_CEIL: + F32_CEIL(ins, stack); + break; + case F32_FLOOR: + F32_FLOOR(ins, stack); + break; + case F32_NEAREST: + F32_NEAREST(ins, stack); + break; + case F32_TRUNC: + F32_TRUNC(ins, stack); + break; + case F32_EQ: + F32_EQ(ins, stack); + break; + case F32_NE: + F32_NE(ins, stack); + break; + case F32_LT: + F32_LT(ins, stack); + break; + case F32_LE: + F32_LE(ins, stack); + break; + case F32_GT: + F32_GT(ins, stack); + break; + case F32_GE: + F32_GE(ins, stack); + break; + case F32_ADD: + F32_ADD(ins, stack); + break; + case F32_SUB: + F32_SUB(ins, stack); + break; + case F32_MUL: + F32_MUL(ins, stack); + break; + case F32_DIV: + F32_DIV(ins, stack); + break; + case F32_MIN: + F32_MIN(ins, stack); + break; + case F32_MAX: + F32_MAX(ins, stack); + break; + case F32_SQRT: + F32_SQRT(ins, stack); + break; + case F32_COPYSIGN: + F32_COPYSIGN(ins, stack); + break; + case F32_CONVERT_I32_S: + F32_CONVERT_I32_S(ins, stack); + break; + case F32_CONVERT_I32_U: + F32_CONVERT_I32_U(ins, stack); + break; + case F32_CONVERT_I64_S: + F32_CONVERT_I64_S(ins, stack); + break; + case F32_CONVERT_I64_U: + F32_CONVERT_I64_U(ins, stack); + break; + case F32_DEMOTE_F64: + F32_DEMOTE_F64(ins, stack); + break; + case F32_REINTERPRET_I32: + F32_REINTERPRET_I32(ins, stack); + break; + case I32_REINTERPRET_F32: + I32_REINTERPRET_F32(ins, stack); + break; + case F32_LOAD: + F32_LOAD(ins, block, stack); + break; + case F32_STORE: + F32_STORE(ins, block, stack); + break; + case F64_NEG: + F64_NEG(ins, stack); + break; + case F64_CONST: + F64_CONST(ins, stack); + break; + case F64_ABS: + F64_ABS(ins, stack); + break; + case F64_CEIL: + F64_CEIL(ins, stack); + break; + case F64_FLOOR: + F64_FLOOR(ins, stack); + break; + case F64_NEAREST: + F64_NEAREST(ins, stack); + break; + case F64_CONVERT_I64_U: + F64_CONVERT_I64_U(ins, stack); + break; + case F64_CONVERT_I64_S: + F64_CONVERT_I64_S(ins, stack); + break; + case F64_CONVERT_I32_S: + F64_CONVERT_I32_S(ins, stack); + break; + case F64_CONVERT_I32_U: + F64_CONVERT_I32_U(ins, stack); + break; + case F64_PROMOTE_F32: + F64_PROMOTE_F32(ins, stack); + break; + case F64_TRUNC: + F64_TRUNC(ins, stack); + break; + case F64_EQ: + F64_EQ(ins, stack); + break; + case F64_NE: + F64_NE(ins, stack); + break; + case F64_LT: + F64_LT(ins, stack); + break; + case F64_LE: + F64_LE(ins, stack); + break; + case F64_GT: + F64_GT(ins, stack); + break; + case F64_GE: + F64_GE(ins, stack); + break; + case F64_MAX: + F64_MAX(ins, stack); + break; + case F64_MIN: + F64_MIN(ins, stack); + break; + case F64_COPYSIGN: + F64_COPYSIGN(ins, stack); + break; + case F64_REINTERPRET_I64: + F64_REINTERPRET_I64(ins, stack); + break; + case F64_ADD: + F64_ADD(ins, stack); + break; + case F64_SUB: + F64_SUB(ins, stack); + break; + case F64_MUL: + F64_MUL(ins, stack); + break; + case F64_DIV: + F64_DIV(ins, stack); + break; + case F64_SQRT: + F64_SQRT(ins, stack); + break; + case F64_LOAD: + F64_LOAD(ins, block, stack); + break; + case F64_STORE: + F64_STORE(ins, block, stack); + break; + case GLOBAL_GET: + GLOBAL_GET(ins, block, stack, globalTypes); + break; + case GLOBAL_SET: + GLOBAL_SET(ins, block, stack, globalTypes); + break; + case DROP: + DROP(ins, block, stack); + break; + case DROP_KEEP: + DROP_KEEP(ins, stack); + break; + case SELECT: + SELECT(ins, block, stack); + break; + case REF_NULL: + REF_NULL(ins, stack); + break; + case REF_FUNC: + REF_FUNC(ins, stack); + break; + case REF_IS_NULL: + REF_IS_NULL(ins, stack); + break; + case MEMORY_GROW: + MEMORY_GROW(ins, block, stack); + break; + case MEMORY_SIZE: + MEMORY_SIZE(ins, stack); + break; + case TABLE_GET: + TABLE_GET(ins, stack); + break; + case TABLE_SET: + TABLE_SET(ins, block, stack); + break; + case TABLE_SIZE: + TABLE_SIZE(ins, stack); + break; + case TABLE_GROW: + TABLE_GROW(ins, stack); + break; + case TABLE_FILL: + TABLE_FILL(ins, block, stack); + break; + case TABLE_COPY: + TABLE_COPY(ins, block, stack); + break; + case TABLE_INIT: + TABLE_INIT(ins, block, stack); + break; + case ELEM_DROP: + ELEM_DROP(ins, block); + break; + case MEMORY_COPY: + MEMORY_COPY(ins, block, stack); + break; + case MEMORY_FILL: + MEMORY_FILL(ins, block, stack); + break; + case MEMORY_INIT: + MEMORY_INIT(ins, block, stack); + break; + case DATA_DROP: + DATA_DROP(ins, block); + break; + default: + throw new IllegalArgumentException("Unsupported opcode: " + op); + } + } + + /** + * Emit I32_CONST: push constant onto stack + * ASM: asm.iconst(value) or asm.visitLdcInsn(value) + * Java: push IntegerLiteralExpr onto expression stack + */ + public static void I32_CONST( + CompilerInstruction ins, Deque stack) { + int value = (int) ins.operand(0); + stack.push(new IntegerLiteralExpr(String.valueOf(value))); + } + + /** + * Emit I32_ADD: pop two values, add them, push result + * ASM: asm.visitInsn(Opcodes.IADD) - assumes two ints are on stack + * Java: pop two expressions, create BinaryExpr with +, push result + */ + public static void I32_ADD( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.PLUS))); + } + + /** + * Emit I32_SUB: pop two values, subtract them, push result + */ + public static void I32_SUB( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.MINUS))); + } + + /** + * Emit I32_MUL: pop two values, multiply them, push result + */ + public static void I32_MUL( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.MULTIPLY))); + } + + public static void I64_ADD( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.PLUS))); + } + + public static void I64_SUB( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.MINUS))); + } + + public static void I64_MUL( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.MULTIPLY))); + } + + public static void I32_WRAP_I64( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + stack.push(new CastExpr(PrimitiveType.intType(), value)); + } + + public static void I32_TRUNC_F32_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I32_TRUNC_F32_S", a)); + } + + public static void I32_TRUNC_F32_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I32_TRUNC_F32_U", a)); + } + + public static void I32_TRUNC_F64_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I32_TRUNC_F64_S", a)); + } + + public static void I32_TRUNC_F64_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I32_TRUNC_F64_U", a)); + } + + public static void I32_TRUNC_SAT_F32_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I32_TRUNC_SAT_F32_S", a)); + } + + public static void I32_TRUNC_SAT_F32_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I32_TRUNC_SAT_F32_U", a)); + } + + public static void I32_TRUNC_SAT_F64_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I32_TRUNC_SAT_F64_S", a)); + } + + public static void I32_TRUNC_SAT_F64_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I32_TRUNC_SAT_F64_U", a)); + } + + public static void I64_DIV_S( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("I64_DIV_S", a, b)); + } + + public static void I64_DIV_U( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("I64_DIV_U", a, b)); + } + + public static void I64_REM_S( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("I64_REM_S", a, b)); + } + + public static void I64_REM_U( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("I64_REM_U", a, b)); + } + + public static void I64_AND( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.BINARY_AND))); + } + + public static void I64_OR( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.BINARY_OR))); + } + + public static void I64_XOR( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.XOR))); + } + + public static void I64_SHL( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.LEFT_SHIFT))); + } + + public static void I64_SHR_S( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.SIGNED_RIGHT_SHIFT))); + } + + public static void I64_SHR_U( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push( + new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT))); + } + + public static void I64_ROTL( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("I64_ROTL", a, b)); + } + + public static void I64_ROTR( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("I64_ROTR", a, b)); + } + + /** + * Emit I32_DIV_S: signed division (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_DIV_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr divCall = new MethodCallExpr(); + divCall.setScope( + StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + divCall.setName("I32_DIV_S"); + divCall.addArgument(a); + divCall.addArgument(b); + stack.push(divCall); + } + + /** + * Emit I32_DIV_U: unsigned division (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_DIV_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr divCall = new MethodCallExpr(); + divCall.setScope( + StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + divCall.setName("I32_DIV_U"); + divCall.addArgument(a); + divCall.addArgument(b); + stack.push(divCall); + } + + /** + * Emit I32_REM_S: signed remainder (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_REM_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr remCall = new MethodCallExpr(); + remCall.setScope( + StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + remCall.setName("I32_REM_S"); + remCall.addArgument(a); + remCall.addArgument(b); + stack.push(remCall); + } + + /** + * Emit I32_REM_U: unsigned remainder (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_REM_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr remCall = new MethodCallExpr(); + remCall.setScope( + StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + remCall.setName("I32_REM_U"); + remCall.addArgument(a); + remCall.addArgument(b); + stack.push(remCall); + } + + /** + * Emit I32_AND: bitwise AND + */ + public static void I32_AND( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.BINARY_AND))); + } + + /** + * Emit I32_OR: bitwise OR + */ + public static void I32_OR( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.BINARY_OR))); + } + + /** + * Emit I32_XOR: bitwise XOR + */ + public static void I32_XOR( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.XOR))); + } + + /** + * Emit I32_SHL: left shift + */ + public static void I32_SHL( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.LEFT_SHIFT))); + } + + /** + * Emit I32_SHR_S: signed right shift + */ + public static void I32_SHR_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.SIGNED_RIGHT_SHIFT))); + } + + /** + * Emit I32_SHR_U: unsigned right shift + */ + public static void I32_SHR_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push( + new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT))); + } + + /** + * Emit I32_ROTL: rotate left (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_ROTL( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr rotlCall = new MethodCallExpr(); + rotlCall.setScope( + StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + rotlCall.setName("I32_ROTL"); + rotlCall.addArgument(a); + rotlCall.addArgument(b); + stack.push(rotlCall); + } + + /** + * Emit I32_ROTR: rotate right (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_ROTR( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr rotrCall = new MethodCallExpr(); + rotrCall.setScope( + StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + rotrCall.setName("I32_ROTR"); + rotrCall.addArgument(a); + rotrCall.addArgument(b); + stack.push(rotrCall); + } + + /** + * Emit I32_CLZ: count leading zeros (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_CLZ( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr clzCall = new MethodCallExpr(); + clzCall.setScope( + StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + clzCall.setName("I32_CLZ"); + clzCall.addArgument(a); + stack.push(clzCall); + } + + /** + * Emit I32_CTZ: count trailing zeros (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_CTZ( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr ctzCall = new MethodCallExpr(); + ctzCall.setScope( + StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + ctzCall.setName("I32_CTZ"); + ctzCall.addArgument(a); + stack.push(ctzCall); + } + + /** + * Emit I32_POPCNT: population count (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_POPCNT( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr popcntCall = new MethodCallExpr(); + popcntCall.setScope( + StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + popcntCall.setName("I32_POPCNT"); + popcntCall.addArgument(a); + stack.push(popcntCall); + } + + /** + * Emit I32_EXTEND_8_S: sign extend 8-bit to 32-bit (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_EXTEND_8_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_EXTEND_8_S"); + call.addArgument(a); + stack.push(call); + } + + /** + * Emit I32_EXTEND_16_S: sign extend 16-bit to 32-bit (matching ASM compiler - uses OpcodeImpl) + */ + public static void I32_EXTEND_16_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_EXTEND_16_S"); + call.addArgument(a); + stack.push(call); + } + + public static void I32_EQZ( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_EQZ"); + call.addArgument(a); + stack.push(call); + } + + public static void I32_EQ( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_EQ"); + call.addArgument(b); + call.addArgument(a); + stack.push(call); + } + + public static void I32_NE( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_NE"); + call.addArgument(b); + call.addArgument(a); + stack.push(call); + } + + public static void I32_LT_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_LT_S"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I32_LT_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_LT_U"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I32_GT_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_GT_S"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I32_GT_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_GT_U"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I32_LE_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_LE_S"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I32_LE_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_LE_U"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I32_GE_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_GE_S"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I32_GE_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I32_GE_U"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I64_EQZ( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_EQZ"); + call.addArgument(a); + stack.push(call); + } + + public static void I64_EQ( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_EQ"); + call.addArgument(b); + call.addArgument(a); + stack.push(call); + } + + public static void I64_NE( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_NE"); + call.addArgument(b); + call.addArgument(a); + stack.push(call); + } + + public static void I64_LT_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_LT_S"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I64_LT_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_LT_U"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I64_GT_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_GT_S"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I64_GT_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_GT_U"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I64_LE_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_LE_S"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I64_LE_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_LE_U"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I64_GE_S( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_GE_S"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I64_GE_U( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("I64_GE_U"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void I64_CLZ( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_CLZ", a)); + } + + public static void I64_CTZ( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_CTZ", a)); + } + + public static void I64_POPCNT( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_POPCNT", a)); + } + + public static void I64_EXTEND_8_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_EXTEND_8_S", a)); + } + + public static void I64_EXTEND_16_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_EXTEND_16_S", a)); + } + + public static void I64_EXTEND_32_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_EXTEND_32_S", a)); + } + + public static void I64_EXTEND_I32_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(new CastExpr(PrimitiveType.longType(), a)); + } + + public static void I64_EXTEND_I32_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_EXTEND_I32_U", a)); + } + + public static void I64_TRUNC_F32_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_TRUNC_F32_S", a)); + } + + public static void I64_TRUNC_F32_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_TRUNC_F32_U", a)); + } + + public static void I64_TRUNC_F64_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_TRUNC_F64_S", a)); + } + + public static void I64_TRUNC_F64_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_TRUNC_F64_U", a)); + } + + public static void I64_TRUNC_SAT_F32_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_TRUNC_SAT_F32_S", a)); + } + + public static void I64_TRUNC_SAT_F32_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_TRUNC_SAT_F32_U", a)); + } + + public static void I64_TRUNC_SAT_F64_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_TRUNC_SAT_F64_S", a)); + } + + public static void I64_TRUNC_SAT_F64_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_TRUNC_SAT_F64_U", a)); + } + + public static void I64_REINTERPRET_F64( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I64_REINTERPRET_F64", a)); + } + + /** + * Emit LOCAL_GET: load local variable onto stack + * ASM: asm.load(ctx.localSlotIndex(loadIndex), asmType(localType)) + * Java: push NameExpr of local variable onto expression stack + */ + public static void LOCAL_GET( + CompilerInstruction ins, + Deque stack, + List localVarNames) { + int localIndex = (int) ins.operand(0); + String varName = localVarNames.get(localIndex); + stack.push(new NameExpr(varName)); + } + + /** + * Emit LOCAL_SET: pop value from stack, store to local. + * Before overwriting, snapshots the variable if it's referenced on the stack + * to avoid aliasing bugs where deferred NameExpr references evaluate to the + * new value instead of the value at the time of local.get. + */ + public static void LOCAL_SET( + CompilerInstruction ins, + BlockStmt block, + BlockStmt funcBlock, + Deque stack, + List localVarNames, + List localVarTypes, + int[] snapIdx) { + int index = (int) ins.operand(0); + String varName = localVarNames.get(index); + com.github.javaparser.ast.expr.Expression value = stack.pop(); + snapshotIfAliased(varName, index, block, funcBlock, stack, localVarTypes, snapIdx); + block.addStatement( + new ExpressionStmt( + new AssignExpr(new NameExpr(varName), value, AssignExpr.Operator.ASSIGN))); + } + + /** + * Emit LOCAL_TEE: store value to local but keep it on stack. + * Before overwriting, snapshots the variable if it's referenced on the stack. + */ + public static void LOCAL_TEE( + CompilerInstruction ins, + BlockStmt block, + BlockStmt funcBlock, + Deque stack, + List localVarNames, + List localVarTypes, + int[] snapIdx) { + int index = (int) ins.operand(0); + String varName = localVarNames.get(index); + com.github.javaparser.ast.expr.Expression value = stack.pop(); + snapshotIfAliased(varName, index, block, funcBlock, stack, localVarTypes, snapIdx); + block.addStatement( + new ExpressionStmt( + new AssignExpr(new NameExpr(varName), value, AssignExpr.Operator.ASSIGN))); + // Push the variable reference (not the original expression) since the + // expression may reference the tee'd variable which was just modified + stack.push(new NameExpr(varName)); + } + + /** + * Check if any expression remaining on the stack references the given local variable. + * If so, emit a snapshot variable and replace all matching NameExprs on the stack. + * This prevents aliasing bugs where local.set overwrites a variable that was + * previously pushed by local.get and is still pending on the expression stack. + * + *

The snapshot is always split into two parts: + *

    + *
  1. A zero-initialized declaration at funcBlock position 0, for scope visibility + * and compatibility with MethodSplitter's local-to-array conversion (which strips + * initializers from declarations). + *
  2. A separate assignment at the correct execution point: + *
      + *
    • Same scope (block == funcBlock): appended to block (current position). + *
    • Inside conditional (if-then/else): inserted in funcBlock before the + * enclosing control-flow statement, so it always executes. + *
    • Non-conditional nested scope (block/loop): appended to block. + *
    + *
+ * + * @param block the current scope block (where local.set is being emitted) + * @param funcBlock the function body block (top-level scope) + */ + private static void snapshotIfAliased( + String varName, + int localIndex, + BlockStmt block, + BlockStmt funcBlock, + Deque stack, + List localVarTypes, + int[] snapIdx) { + boolean hasAlias = false; + for (com.github.javaparser.ast.expr.Expression expr : stack) { + if (referencesVariable(expr, varName)) { + hasAlias = true; + break; + } + } + if (!hasAlias) { + return; + } + + String snapName = "_snap_" + (snapIdx[0]++); + String typeName = SourceCompilerUtil.javaTypeName(localVarTypes.get(localIndex)); + + // Always declare at function body level with zero init. + // MethodSplitter's convertLocalsToArrays removes declarations but preserves + // assignment statements, so we must never put the real value in the initializer. + funcBlock.addStatement( + 0, StaticJavaParser.parseStatement(typeName + " " + snapName + " = 0;")); + + if (block == funcBlock) { + // Same scope: assign at the current position + block.addStatement(StaticJavaParser.parseStatement(snapName + " = " + varName + ";")); + } else { + // Check if block is inside a conditional (if-then/else) by walking up + boolean inConditional = false; + Node check = block; + while (check != null && check != funcBlock) { + Node p = check.getParentNode().orElse(null); + if (p instanceof IfStmt) { + inConditional = true; + break; + } + check = p; + } + + if (inConditional) { + // Walk up to funcBlock to find the direct child statement that + // contains this block, and insert the assignment before it. + // This ensures the snapshot always executes regardless of which + // branch of the if-else is taken. + Node cursor = block; + Statement funcChild = null; + while (cursor != null) { + Node p = cursor.getParentNode().orElse(null); + if (p == funcBlock && cursor instanceof Statement) { + funcChild = (Statement) cursor; + break; + } + cursor = p; + } + if (funcChild != null) { + int idx = funcBlock.getStatements().indexOf(funcChild); + if (idx >= 0) { + funcBlock + .getStatements() + .add( + idx, + StaticJavaParser.parseStatement( + snapName + " = " + varName + ";")); + } else { + block.addStatement( + StaticJavaParser.parseStatement(snapName + " = " + varName + ";")); + } + } else { + block.addStatement( + StaticJavaParser.parseStatement(snapName + " = " + varName + ";")); + } + } else { + // Non-conditional nested scope: assign at current block + block.addStatement( + StaticJavaParser.parseStatement(snapName + " = " + varName + ";")); + } + } + + // Replace all NameExpr references to varName with snapName in the stack + ArrayDeque replacement = new ArrayDeque<>(); + for (com.github.javaparser.ast.expr.Expression expr : stack) { + replacement.addLast(replaceVariable(expr, varName, snapName)); + } + stack.clear(); + for (com.github.javaparser.ast.expr.Expression expr : replacement) { + stack.addLast(expr); + } + } + + /** + * Check if an expression tree contains a NameExpr referencing the given variable. + */ + private static boolean referencesVariable( + com.github.javaparser.ast.expr.Expression expr, String varName) { + if (expr instanceof NameExpr) { + return ((NameExpr) expr).getNameAsString().equals(varName); + } + // Check child expressions recursively + for (var child : expr.getChildNodes()) { + if (child instanceof com.github.javaparser.ast.expr.Expression) { + if (referencesVariable( + (com.github.javaparser.ast.expr.Expression) child, varName)) { + return true; + } + } + } + return false; + } + + /** + * Replace all NameExpr references to oldName with newName in an expression tree. + * Returns a new expression (or the same one if no replacement was needed). + */ + private static com.github.javaparser.ast.expr.Expression replaceVariable( + com.github.javaparser.ast.expr.Expression expr, String oldName, String newName) { + if (expr instanceof NameExpr && ((NameExpr) expr).getNameAsString().equals(oldName)) { + return new NameExpr(newName); + } + // For compound expressions, clone and replace children + if (referencesVariable(expr, oldName)) { + com.github.javaparser.ast.expr.Expression cloned = expr.clone(); + replaceVariableInPlace(cloned, oldName, newName); + return cloned; + } + return expr; + } + + /** + * In-place replacement of NameExpr references within a cloned expression tree. + */ + private static void replaceVariableInPlace( + com.github.javaparser.ast.Node node, String oldName, String newName) { + if (node instanceof NameExpr && ((NameExpr) node).getNameAsString().equals(oldName)) { + ((NameExpr) node).setName(new SimpleName(newName)); + return; + } + for (var child : node.getChildNodes()) { + replaceVariableInPlace(child, oldName, newName); + } + } + + /** + * Emit CALL: call function by ID. + * Boxes args to long[], dispatches via instance.getMachine().call(), unboxes result. + */ + public static void CALL( + CompilerInstruction ins, + BlockStmt block, + Deque stack, + List allFunctionTypes, + int[] callIdx) { + int funcId = (int) ins.operand(0); + FunctionType calledFunctionType = allFunctionTypes.get(funcId); + emitCallWithArgs(block, stack, calledFunctionType, String.valueOf(funcId), callIdx); + } + + /** + * Emit CALL_INDIRECT: resolve function from table, type-check, and call. + * Mirrors ASM compiler's CALL_INDIRECT + compileCallIndirect. + * + * Cross-module dispatch: table entries store both a funcId and the Instance + * that owns the function. We must dispatch through that Instance's machine, + * not the current module's machine. + */ + public static void CALL_INDIRECT( + CompilerInstruction ins, + BlockStmt block, + Deque stack, + FunctionType[] typeSectionTypes, + int[] callIdx) { + int typeId = (int) ins.operand(0); + int tableIdx = (int) ins.operand(1); + FunctionType calledFunctionType = typeSectionTypes[typeId]; + + // Pop the table entry index (topmost on the expression stack) + com.github.javaparser.ast.expr.Expression entryIdx = stack.pop(); + + int idx = callIdx[0]; + + // Store entry index in a local (may be a complex expression, used twice) + block.addStatement( + StaticJavaParser.parseStatement( + "int ciTableIdx_" + idx + " = (int)(" + entryIdx + ");")); + + // Resolve function ID from table + block.addStatement( + StaticJavaParser.parseStatement( + "int ciFuncId_" + + idx + + " = instance.table(" + + tableIdx + + ").requiredRef(ciTableIdx_" + + idx + + ");")); + + // Get the owning instance for this table entry (for cross-module dispatch) + block.addStatement( + StaticJavaParser.parseStatement( + "com.dylibso.chicory.runtime.Instance ciRefInstance_" + + idx + + " = java.util.Objects.requireNonNullElse(" + + "instance.table(" + + tableIdx + + ").instance(ciTableIdx_" + + idx + + "), instance);")); + + // Type check using refInstance for the actual function type + block.addStatement( + StaticJavaParser.parseStatement( + "if (!ciRefInstance_" + + idx + + ".type(ciRefInstance_" + + idx + + ".functionType(ciFuncId_" + + idx + + "))" + + ".typesMatch(instance.type(" + + typeId + + "))) { throw new" + + " com.dylibso.chicory.wasm.ChicoryException(" + + "\"indirect call type mismatch\"); }")); + + emitCallWithArgs( + block, + stack, + calledFunctionType, + "ciFuncId_" + idx, + callIdx, + "ciRefInstance_" + idx); + } + + /** + * Shared helper: box args from expression stack, call via Machine, unbox result. + * Used by CALL (always dispatches through current instance). + */ + private static void emitCallWithArgs( + BlockStmt block, + Deque stack, + FunctionType calledFunctionType, + String funcIdExpr, + int[] callIdx) { + emitCallWithArgs(block, stack, calledFunctionType, funcIdExpr, callIdx, "instance"); + } + + /** + * Shared helper: box args from expression stack, call via Machine, unbox result. + * The instanceExpr parameter controls which instance's machine is used for dispatch. + * For CALL this is always "instance"; for CALL_INDIRECT it may be the refInstance + * from the table entry (for cross-module calls). + */ + private static void emitCallWithArgs( + BlockStmt block, + Deque stack, + FunctionType calledFunctionType, + String funcIdExpr, + int[] callIdx, + String instanceExpr) { + int paramCount = calledFunctionType.params().size(); + int idx = callIdx[0]++; + + // Box args from the expression stack + String argsExpr; + if (paramCount == 0) { + argsExpr = "new long[0]"; + } else { + String argsVar = "callArgs_" + idx; + block.addStatement( + StaticJavaParser.parseStatement( + "long[] " + argsVar + " = new long[" + paramCount + "];")); + for (int i = paramCount - 1; i >= 0; i--) { + com.github.javaparser.ast.expr.Expression arg = stack.pop(); + String boxExpr = + SourceCompilerUtil.boxJvmToLong( + arg.toString(), calledFunctionType.params().get(i)); + block.addStatement( + StaticJavaParser.parseStatement( + argsVar + "[" + i + "] = " + boxExpr + ";")); + } + argsExpr = argsVar; + } + + // Dispatch via Machine interface through the specified instance + String callExpr = instanceExpr + ".getMachine().call(" + funcIdExpr + ", " + argsExpr + ")"; + + // Handle return value + if (calledFunctionType.returns().isEmpty()) { + block.addStatement(StaticJavaParser.parseStatement(callExpr + ";")); + } else if (calledFunctionType.returns().size() == 1) { + String resultVar = "callResult_" + idx; + block.addStatement( + StaticJavaParser.parseStatement( + "long[] " + resultVar + " = " + callExpr + ";")); + String unboxExpr = + SourceCompilerUtil.unboxLongToJvm( + resultVar + "[0]", calledFunctionType.returns().get(0)); + stack.push(StaticJavaParser.parseExpression(unboxExpr)); + } else { + // Multi-return: declare result array, push one expression per return value + String resultVar = "callResult_" + idx; + block.addStatement( + StaticJavaParser.parseStatement( + "long[] " + resultVar + " = " + callExpr + ";")); + for (int i = 0; i < calledFunctionType.returns().size(); i++) { + String unboxExpr = + SourceCompilerUtil.unboxLongToJvm( + resultVar + "[" + i + "]", calledFunctionType.returns().get(i)); + stack.push(StaticJavaParser.parseExpression(unboxExpr)); + } + } + } + + /** + * Emit RETURN: handle inline, matching ASM compiler behavior + */ + public static void RETURN( + CompilerInstruction ins, + BlockStmt block, + Deque stack, + FunctionType functionType) { + var statements = block.getStatements(); + if (!statements.isEmpty() && statements.get(statements.size() - 1) instanceof ThrowStmt) { + return; + } + + Class returnType = SourceCompilerUtil.jvmReturnType(functionType); + + if (returnType == void.class) { + // Pop and discard any values on stack + while (!stack.isEmpty()) { + stack.pop(); + } + block.addStatement(StaticJavaParser.parseStatement("return;")); + } else if (returnType == long[].class) { + if (stack.isEmpty()) { + return; + } + // Multiple return values - box into long[] + block.addStatement( + StaticJavaParser.parseStatement( + "long[] out = new long[" + functionType.returns().size() + "];")); + for (int i = functionType.returns().size() - 1; i >= 0; i--) { + com.github.javaparser.ast.expr.Expression resultExpr = stack.pop(); + String boxExpr = + SourceCompilerUtil.boxJvmToLong( + resultExpr.toString(), functionType.returns().get(i)); + block.addStatement( + StaticJavaParser.parseStatement("out[" + i + "] = " + boxExpr + ";")); + } + block.addStatement(new ReturnStmt(new NameExpr("out"))); + } else { + if (stack.isEmpty()) { + return; + } + // Single return value - return directly + com.github.javaparser.ast.expr.Expression resultExpr = stack.pop(); + block.addStatement(new ReturnStmt(resultExpr)); + } + } + + /** + * Generate getAddr expression: (base < 0) ? base : base + offset + * Matching ASM compiler's Shaded.getAddr logic + */ + private static com.github.javaparser.ast.expr.Expression getAddrExpr( + com.github.javaparser.ast.expr.Expression base, int offset) { + BinaryExpr basePlusOffset = + new BinaryExpr( + base, + new IntegerLiteralExpr(String.valueOf(offset)), + BinaryExpr.Operator.PLUS); + BinaryExpr baseLessThanZero = + new BinaryExpr(base, new IntegerLiteralExpr("0"), BinaryExpr.Operator.LESS); + return new ConditionalExpr(baseLessThanZero, base, basePlusOffset); + } + + private static MethodCallExpr opcodeImplCall( + String name, com.github.javaparser.ast.expr.Expression... args) { + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName(name); + for (var arg : args) { + call.addArgument(arg); + } + return call; + } + + public static void I32_LOAD( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("readInt"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + stack.push(call); + } + + public static void I32_STORE( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("writeI32"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + call.addArgument(new CastExpr(PrimitiveType.intType(), value)); + block.addStatement(new ExpressionStmt(call)); + } + + public static void I32_LOAD8_S( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr readCall = new MethodCallExpr(); + readCall.setScope(new NameExpr("memory")); + readCall.setName("read"); + readCall.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + stack.push( + new CastExpr( + PrimitiveType.intType(), new CastExpr(PrimitiveType.byteType(), readCall))); + } + + public static void I32_LOAD8_U( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr readCall = new MethodCallExpr(); + readCall.setScope(new NameExpr("memory")); + readCall.setName("read"); + readCall.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + stack.push( + new com.github.javaparser.ast.expr.EnclosedExpr( + new BinaryExpr( + new CastExpr(PrimitiveType.intType(), readCall), + new IntegerLiteralExpr("0xFF"), + BinaryExpr.Operator.BINARY_AND))); + } + + public static void I32_LOAD16_S( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr readCall = new MethodCallExpr(); + readCall.setScope(new NameExpr("memory")); + readCall.setName("readShort"); + readCall.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + stack.push( + new CastExpr( + PrimitiveType.intType(), + new CastExpr(PrimitiveType.shortType(), readCall))); + } + + public static void I32_LOAD16_U( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr readCall = new MethodCallExpr(); + readCall.setScope(new NameExpr("memory")); + readCall.setName("readShort"); + readCall.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + stack.push( + new com.github.javaparser.ast.expr.EnclosedExpr( + new BinaryExpr( + new CastExpr(PrimitiveType.intType(), readCall), + new IntegerLiteralExpr("0xFFFF"), + BinaryExpr.Operator.BINARY_AND))); + } + + public static void I32_STORE8( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + CastExpr byteValue = + new CastExpr( + PrimitiveType.byteType(), + new com.github.javaparser.ast.expr.EnclosedExpr(value)); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("writeByte"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + call.addArgument(byteValue); + block.addStatement(new ExpressionStmt(call)); + } + + public static void I32_STORE16( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + CastExpr shortValue = + new CastExpr( + PrimitiveType.shortType(), + new com.github.javaparser.ast.expr.EnclosedExpr(value)); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("writeShort"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + call.addArgument(shortValue); + block.addStatement(new ExpressionStmt(call)); + } + + public static void I64_CONST( + CompilerInstruction ins, Deque stack) { + long value = ins.operand(0); + stack.push(new com.github.javaparser.ast.expr.LongLiteralExpr(String.valueOf(value) + "L")); + } + + public static void I64_LOAD( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("readLong"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + stack.push(call); + } + + public static void I64_LOAD8_S( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + I32_LOAD8_S(ins, block, stack); + com.github.javaparser.ast.expr.Expression value = stack.pop(); + stack.push(new CastExpr(PrimitiveType.longType(), value)); + } + + public static void I64_LOAD8_U( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + I32_LOAD8_U(ins, block, stack); + com.github.javaparser.ast.expr.Expression value = stack.pop(); + stack.push(new CastExpr(PrimitiveType.longType(), value)); + } + + public static void I64_LOAD16_S( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + I32_LOAD16_S(ins, block, stack); + com.github.javaparser.ast.expr.Expression value = stack.pop(); + stack.push(new CastExpr(PrimitiveType.longType(), value)); + } + + public static void I64_LOAD16_U( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + I32_LOAD16_U(ins, block, stack); + com.github.javaparser.ast.expr.Expression value = stack.pop(); + stack.push(new CastExpr(PrimitiveType.longType(), value)); + } + + public static void I64_LOAD32_S( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + I32_LOAD(ins, block, stack); + com.github.javaparser.ast.expr.Expression value = stack.pop(); + stack.push(new CastExpr(PrimitiveType.longType(), value)); + } + + public static void I64_LOAD32_U( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + I32_LOAD(ins, block, stack); + com.github.javaparser.ast.expr.Expression value = stack.pop(); + stack.push( + new com.github.javaparser.ast.expr.EnclosedExpr( + new BinaryExpr( + new CastExpr(PrimitiveType.longType(), value), + new com.github.javaparser.ast.expr.LongLiteralExpr("0xFFFFFFFFL"), + BinaryExpr.Operator.BINARY_AND))); + } + + public static void I64_STORE( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("writeLong"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + call.addArgument(new CastExpr(PrimitiveType.longType(), value)); + block.addStatement(new ExpressionStmt(call)); + } + + public static void I64_STORE8( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + CastExpr intValue = + new CastExpr( + PrimitiveType.intType(), + new com.github.javaparser.ast.expr.EnclosedExpr(value)); + CastExpr byteValue = new CastExpr(PrimitiveType.byteType(), intValue); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("writeByte"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + call.addArgument(byteValue); + block.addStatement(new ExpressionStmt(call)); + } + + public static void I64_STORE16( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + CastExpr intValue = + new CastExpr( + PrimitiveType.intType(), + new com.github.javaparser.ast.expr.EnclosedExpr(value)); + CastExpr shortValue = new CastExpr(PrimitiveType.shortType(), intValue); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("writeShort"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + call.addArgument(shortValue); + block.addStatement(new ExpressionStmt(call)); + } + + public static void I64_STORE32( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + CastExpr intValue = new CastExpr(PrimitiveType.intType(), value); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("writeI32"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + call.addArgument(intValue); + block.addStatement(new ExpressionStmt(call)); + } + + public static void F32_LOAD( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("readFloat"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + stack.push(call); + } + + public static void F32_STORE( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("writeF32"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + call.addArgument(new CastExpr(PrimitiveType.floatType(), value)); + block.addStatement(new ExpressionStmt(call)); + } + + public static void F32_NEG( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new UnaryExpr(a, UnaryExpr.Operator.MINUS)); + } + + public static void F32_CONST( + CompilerInstruction ins, Deque stack) { + int bits = (int) ins.operand(0); + float value = Float.intBitsToFloat(bits); + String literal; + if (Float.isNaN(value)) { + literal = "Float.intBitsToFloat(" + bits + ")"; + } else if (value == Float.POSITIVE_INFINITY) { + literal = "Float.POSITIVE_INFINITY"; + } else if (value == Float.NEGATIVE_INFINITY) { + literal = "Float.NEGATIVE_INFINITY"; + } else { + literal = Float.toString(value) + "f"; + } + stack.push(StaticJavaParser.parseExpression(literal)); + } + + public static void F32_ABS( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F32_ABS", a)); + } + + public static void F32_CEIL( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F32_CEIL", a)); + } + + public static void F32_FLOOR( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F32_FLOOR", a)); + } + + public static void F32_NEAREST( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F32_NEAREST", a)); + } + + public static void F32_TRUNC( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F32_TRUNC", a)); + } + + public static void F32_COPYSIGN( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F32_COPYSIGN", a, b)); + } + + public static void F32_REINTERPRET_I32( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F32_REINTERPRET_I32", a)); + } + + public static void I32_REINTERPRET_F32( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("I32_REINTERPRET_F32", a)); + } + + public static void F32_CONVERT_I32_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F32_CONVERT_I32_S", a)); + } + + public static void F32_CONVERT_I32_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F32_CONVERT_I32_U", a)); + } + + public static void F32_CONVERT_I64_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F32_CONVERT_I64_S", a)); + } + + public static void F32_CONVERT_I64_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F32_CONVERT_I64_U", a)); + } + + public static void F32_DEMOTE_F64( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new CastExpr(PrimitiveType.floatType(), a)); + } + + public static void F32_EQ( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F32_EQ", a, b)); + } + + public static void F32_NE( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F32_NE", a, b)); + } + + public static void F32_LT( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F32_LT", a, b)); + } + + public static void F32_LE( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F32_LE", a, b)); + } + + public static void F32_GT( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F32_GT", a, b)); + } + + public static void F32_GE( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F32_GE", a, b)); + } + + public static void F32_ADD( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.PLUS))); + } + + public static void F32_SUB( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.MINUS))); + } + + public static void F32_MUL( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.MULTIPLY))); + } + + public static void F32_DIV( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.DIVIDE))); + } + + public static void F32_MIN( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("F32_MIN"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void F32_MAX( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("F32_MAX"); + call.addArgument(a); + call.addArgument(b); + stack.push(call); + } + + public static void F32_SQRT( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(StaticJavaParser.parseExpression("com.dylibso.chicory.runtime.OpcodeImpl")); + call.setName("F32_SQRT"); + call.addArgument(a); + stack.push(call); + } + + public static void F64_LOAD( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("readDouble"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + stack.push(call); + } + + public static void F64_STORE( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + com.github.javaparser.ast.expr.Expression base = stack.pop(); + long offset = ins.operand(1); + com.github.javaparser.ast.expr.Expression addrExpr = getAddrExpr(base, (int) offset); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(new NameExpr("memory")); + call.setName("writeF64"); + call.addArgument(new CastExpr(PrimitiveType.intType(), addrExpr)); + call.addArgument(new CastExpr(PrimitiveType.doubleType(), value)); + block.addStatement(new ExpressionStmt(call)); + } + + public static void F64_NEG( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new UnaryExpr(a, UnaryExpr.Operator.MINUS)); + } + + public static void F64_CONST( + CompilerInstruction ins, Deque stack) { + long bits = ins.operand(0); + double value = Double.longBitsToDouble(bits); + String literal; + if (Double.isNaN(value)) { + literal = "Double.longBitsToDouble(" + bits + "L)"; + } else if (value == Double.POSITIVE_INFINITY) { + literal = "Double.POSITIVE_INFINITY"; + } else if (value == Double.NEGATIVE_INFINITY) { + literal = "Double.NEGATIVE_INFINITY"; + } else { + literal = Double.toString(value); + } + stack.push(StaticJavaParser.parseExpression(literal)); + } + + public static void F64_ABS( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_ABS", a)); + } + + public static void F64_CEIL( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_CEIL", a)); + } + + public static void F64_CONVERT_I64_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_CONVERT_I64_U", a)); + } + + public static void F64_CONVERT_I64_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_CONVERT_I64_S", a)); + } + + public static void F64_CONVERT_I32_S( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_CONVERT_I32_S", a)); + } + + public static void F64_CONVERT_I32_U( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_CONVERT_I32_U", a)); + } + + public static void F64_PROMOTE_F32( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new CastExpr(PrimitiveType.doubleType(), a)); + } + + public static void F64_ADD( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.PLUS))); + } + + public static void F64_SUB( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.MINUS))); + } + + public static void F64_MUL( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.MULTIPLY))); + } + + public static void F64_DIV( + CompilerInstruction ins, Deque stack) { + com.github.javaparser.ast.expr.Expression b = stack.pop(); + com.github.javaparser.ast.expr.Expression a = stack.pop(); + stack.push(new EnclosedExpr(new BinaryExpr(a, b, BinaryExpr.Operator.DIVIDE))); + } + + public static void F64_SQRT( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_SQRT", a)); + } + + public static void F64_FLOOR( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_FLOOR", a)); + } + + public static void F64_NEAREST( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_NEAREST", a)); + } + + public static void F64_TRUNC( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_TRUNC", a)); + } + + public static void F64_COPYSIGN( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F64_COPYSIGN", a, b)); + } + + public static void F64_REINTERPRET_I64( + CompilerInstruction ins, Deque stack) { + var a = stack.pop(); + stack.push(opcodeImplCall("F64_REINTERPRET_I64", a)); + } + + public static void F64_EQ( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F64_EQ", a, b)); + } + + public static void F64_NE( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F64_NE", a, b)); + } + + public static void F64_LT( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F64_LT", a, b)); + } + + public static void F64_LE( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F64_LE", a, b)); + } + + public static void F64_GT( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F64_GT", a, b)); + } + + public static void F64_GE( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F64_GE", a, b)); + } + + public static void F64_MAX( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F64_MAX", a, b)); + } + + public static void F64_MIN( + CompilerInstruction ins, Deque stack) { + var b = stack.pop(); + var a = stack.pop(); + stack.push(opcodeImplCall("F64_MIN", a, b)); + } + + public static void GLOBAL_GET( + CompilerInstruction ins, + BlockStmt block, + Deque stack, + List globalTypes) { + int globalIndex = (int) ins.operand(0); + MethodCallExpr globalCall = new MethodCallExpr(); + globalCall.setScope(new NameExpr("instance")); + globalCall.setName("global"); + globalCall.addArgument(new IntegerLiteralExpr(String.valueOf(globalIndex))); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(globalCall); + call.setName("getValue"); + ValType type = globalTypes.get(globalIndex); + String unboxed = SourceCompilerUtil.unboxLongToJvm(call.toString(), type); + stack.push(StaticJavaParser.parseExpression(unboxed)); + } + + public static void GLOBAL_SET( + CompilerInstruction ins, + BlockStmt block, + Deque stack, + List globalTypes) { + com.github.javaparser.ast.expr.Expression value = stack.pop(); + int globalIndex = (int) ins.operand(0); + ValType type = globalTypes.get(globalIndex); + String boxed = SourceCompilerUtil.boxJvmToLong(value.toString(), type); + MethodCallExpr globalCall = new MethodCallExpr(); + globalCall.setScope(new NameExpr("instance")); + globalCall.setName("global"); + globalCall.addArgument(new IntegerLiteralExpr(String.valueOf(globalIndex))); + MethodCallExpr call = new MethodCallExpr(); + call.setScope(globalCall); + call.setName("setValue"); + call.addArgument(StaticJavaParser.parseExpression(boxed)); + block.addStatement(new ExpressionStmt(call)); + } + + public static void DROP( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + if (!stack.isEmpty()) { + com.github.javaparser.ast.expr.Expression expr = stack.pop(); + // Emit method calls as statements to preserve side effects + // (e.g. memory.grow() has a side effect even if the result is dropped) + if (expr instanceof MethodCallExpr) { + block.addStatement(new ExpressionStmt(expr)); + } + } + } + + public static void DROP_KEEP( + CompilerInstruction ins, Deque stack) { + int drop = (int) ins.operand(0); + int keep = ins.operandCount() - 1 - drop; + + if (drop <= 0) { + return; + } + + // Save the top 'keep' values + com.github.javaparser.ast.expr.Expression[] saved = + new com.github.javaparser.ast.expr.Expression[keep]; + for (int i = 0; i < keep; i++) { + saved[i] = stack.pop(); + } + // Drop the next 'drop' values + for (int i = 0; i < drop && !stack.isEmpty(); i++) { + stack.pop(); + } + // Restore the saved values (in reverse order so top stays on top) + for (int i = keep - 1; i >= 0; i--) { + stack.push(saved[i]); + } + } + + public static void SELECT( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + // WASM stack: [val1, val2, cond] → cond != 0 ? val1 : val2 + com.github.javaparser.ast.expr.Expression condition = stack.pop(); + com.github.javaparser.ast.expr.Expression val2 = stack.pop(); + com.github.javaparser.ast.expr.Expression val1 = stack.pop(); + BinaryExpr condExpr = + new BinaryExpr( + condition, new IntegerLiteralExpr("0"), BinaryExpr.Operator.NOT_EQUALS); + com.github.javaparser.ast.expr.ConditionalExpr ternary = + new com.github.javaparser.ast.expr.ConditionalExpr(condExpr, val1, val2); + stack.push(new com.github.javaparser.ast.expr.EnclosedExpr(ternary)); + } + + /** + * Emit MEMORY_GROW: grow memory by given number of pages. + * Mirrors ASM compiler: calls memory.grow(size), returns old page count or -1. + */ + public static void MEMORY_GROW( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression size = stack.pop(); + stack.push(StaticJavaParser.parseExpression("memory.grow(" + size + ")")); + } + + /** + * Emit MEMORY_SIZE: return current memory size in pages. + * Mirrors ASM compiler: calls memory.pages(). + */ + public static void MEMORY_SIZE( + CompilerInstruction ins, Deque stack) { + stack.push(StaticJavaParser.parseExpression("memory.pages()")); + } + + /** + * Emit MEMORY_COPY: copy region of memory. + * Stack: [dst, src, size] -> [] + * Mirrors ASM compiler: calls memory.copy(dst, src, size). + */ + public static void REF_NULL( + CompilerInstruction ins, Deque stack) { + stack.push( + StaticJavaParser.parseExpression( + "com.dylibso.chicory.wasm.types.Value.REF_NULL_VALUE")); + } + + public static void REF_FUNC( + CompilerInstruction ins, Deque stack) { + int funcIdx = (int) ins.operand(0); + stack.push(new IntegerLiteralExpr(String.valueOf(funcIdx))); + } + + public static void REF_IS_NULL( + CompilerInstruction ins, Deque stack) { + var ref = stack.pop(); + stack.push( + new com.github.javaparser.ast.expr.EnclosedExpr( + new ConditionalExpr( + new BinaryExpr( + ref, + StaticJavaParser.parseExpression( + "com.dylibso.chicory.wasm.types.Value.REF_NULL_VALUE"), + BinaryExpr.Operator.EQUALS), + new IntegerLiteralExpr("1"), + new IntegerLiteralExpr("0")))); + } + + public static void TABLE_GET( + CompilerInstruction ins, Deque stack) { + int tableIndex = (int) ins.operand(0); + var index = stack.pop(); + stack.push( + StaticJavaParser.parseExpression( + "com.dylibso.chicory.runtime.OpcodeImpl.TABLE_GET(instance, " + + tableIndex + + ", " + + index + + ")")); + } + + public static void TABLE_SET( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + int tableIndex = (int) ins.operand(0); + var value = stack.pop(); + var index = stack.pop(); + block.addStatement( + StaticJavaParser.parseExpression( + "instance.table(" + + tableIndex + + ").setRef(" + + index + + ", " + + value + + ", instance)")); + } + + public static void TABLE_SIZE( + CompilerInstruction ins, Deque stack) { + int tableIndex = (int) ins.operand(0); + stack.push(StaticJavaParser.parseExpression("instance.table(" + tableIndex + ").size()")); + } + + public static void TABLE_GROW( + CompilerInstruction ins, Deque stack) { + int tableIndex = (int) ins.operand(0); + var size = stack.pop(); + var value = stack.pop(); + stack.push( + StaticJavaParser.parseExpression( + "instance.table(" + + tableIndex + + ").grow(" + + size + + ", " + + value + + ", instance)")); + } + + public static void TABLE_FILL( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + int tableIndex = (int) ins.operand(0); + var size = stack.pop(); + var value = stack.pop(); + var offset = stack.pop(); + block.addStatement( + StaticJavaParser.parseExpression( + "com.dylibso.chicory.runtime.OpcodeImpl.TABLE_FILL(instance, " + + tableIndex + + ", " + + size + + ", " + + value + + ", " + + offset + + ")")); + } + + public static void TABLE_COPY( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + int dstTableIndex = (int) ins.operand(0); + int srcTableIndex = (int) ins.operand(1); + var size = stack.pop(); + var s = stack.pop(); + var d = stack.pop(); + block.addStatement( + StaticJavaParser.parseExpression( + "com.dylibso.chicory.runtime.OpcodeImpl.TABLE_COPY(instance, " + + srcTableIndex + + ", " + + dstTableIndex + + ", " + + size + + ", " + + s + + ", " + + d + + ")")); + } + + public static void TABLE_INIT( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + int elementidx = (int) ins.operand(0); + int tableidx = (int) ins.operand(1); + var size = stack.pop(); + var elemidx = stack.pop(); + var offset = stack.pop(); + block.addStatement( + StaticJavaParser.parseExpression( + "com.dylibso.chicory.runtime.OpcodeImpl.TABLE_INIT(instance, " + + tableidx + + ", " + + elementidx + + ", " + + size + + ", " + + elemidx + + ", " + + offset + + ")")); + } + + public static void ELEM_DROP(CompilerInstruction ins, BlockStmt block) { + int index = (int) ins.operand(0); + block.addStatement( + StaticJavaParser.parseExpression("instance.setElement(" + index + ", null)")); + } + + public static void MEMORY_COPY( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression size = stack.pop(); + com.github.javaparser.ast.expr.Expression src = stack.pop(); + com.github.javaparser.ast.expr.Expression dst = stack.pop(); + block.addStatement( + StaticJavaParser.parseExpression( + "memory.copy(" + dst + ", " + src + ", " + size + ")")); + } + + /** + * Emit MEMORY_FILL: fill memory region with a byte value. + * Stack: [offset, val, size] -> [] + * Mirrors ASM/interpreter: calls memory.fill((byte)val, offset, size + offset). + */ + public static void MEMORY_FILL( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + com.github.javaparser.ast.expr.Expression size = stack.pop(); + com.github.javaparser.ast.expr.Expression val = stack.pop(); + com.github.javaparser.ast.expr.Expression offset = stack.pop(); + block.addStatement( + StaticJavaParser.parseExpression( + "memory.fill((byte) " + + val + + ", " + + offset + + ", " + + size + + " + " + + offset + + ")")); + } + + /** + * Emit MEMORY_INIT: initialize memory from a data segment. + * Stack: [dst, src_offset, size] -> [] + * operand(0) = segment index + * Mirrors ASM/interpreter: calls memory.initPassiveSegment(segmentId, dst, offset, size). + */ + public static void MEMORY_INIT( + CompilerInstruction ins, + BlockStmt block, + Deque stack) { + int segmentId = (int) ins.operand(0); + com.github.javaparser.ast.expr.Expression size = stack.pop(); + com.github.javaparser.ast.expr.Expression srcOffset = stack.pop(); + com.github.javaparser.ast.expr.Expression dst = stack.pop(); + block.addStatement( + StaticJavaParser.parseExpression( + "memory.initPassiveSegment(" + + segmentId + + ", " + + dst + + ", " + + srcOffset + + ", " + + size + + ")")); + } + + /** + * Emit DATA_DROP: drop a data segment. + * Stack: [] -> [] + * operand(0) = segment index + * Mirrors ASM/interpreter: calls memory.drop(segment). + */ + public static void DATA_DROP(CompilerInstruction ins, BlockStmt block) { + int segment = (int) ins.operand(0); + block.addStatement(StaticJavaParser.parseExpression("memory.drop(" + segment + ")")); + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SourceCompilerUtil.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SourceCompilerUtil.java new file mode 100644 index 000000000..d2525857c --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/SourceCompilerUtil.java @@ -0,0 +1,222 @@ +package com.dylibso.chicory.source.compiler.internal; + +import com.dylibso.chicory.wasm.types.FunctionBody; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.ValType; +import com.github.javaparser.StaticJavaParser; +import com.github.javaparser.ast.type.ArrayType; +import com.github.javaparser.ast.type.PrimitiveType; +import java.util.List; + +/** + * Utility methods for source code compilation. + * Mirrors the structure of the ASM compiler's CompilerUtil. + */ +final class SourceCompilerUtil { + + private SourceCompilerUtil() {} + + // The maximum number of wasm parameters that can be passed to a function before we box them + // since Java methods have a limit of 255 parameters, but we need to reserve a few for the + // Instance and Memory args. + private static final int MAX_PARAMETER_COUNT = 253; + + /** + * Convert ValType to JVM type (mirrors CompilerUtil.jvmType). + */ + public static Class jvmType(ValType type) { + switch (type.opcode()) { + case ValType.ID.I32: + case ValType.ID.Ref: + case ValType.ID.RefNull: + case ValType.ID.ExnRef: + return int.class; + case ValType.ID.I64: + return long.class; + case ValType.ID.F32: + return float.class; + case ValType.ID.F64: + return double.class; + default: + throw new IllegalArgumentException("Unsupported ValType: " + type); + } + } + + /** + * Get JVM return type for a function (mirrors CompilerUtil.jvmReturnType). + */ + public static Class jvmReturnType(FunctionType type) { + switch (type.returns().size()) { + case 0: + return void.class; + case 1: + return jvmType(type.returns().get(0)); + default: + return long[].class; + } + } + + /** + * Get JVM parameter types for a function (mirrors CompilerUtil.jvmParameterTypes). + */ + public static Class[] jvmParameterTypes(FunctionType type) { + return jvmTypes(type.params()); + } + + /** + * Convert list of ValTypes to JVM types (mirrors CompilerUtil.jvmTypes). + */ + public static Class[] jvmTypes(List types) { + return types.stream().map(SourceCompilerUtil::jvmType).toArray(Class[]::new); + } + + /** + * Check if function has too many parameters (mirrors CompilerUtil.hasTooManyParameters). + */ + public static boolean hasTooManyParameters(FunctionType type) { + return type.params().stream().mapToInt(SourceCompilerUtil::slotCount).sum() + > MAX_PARAMETER_COUNT; + } + + /** + * Get slot count for a ValType (mirrors CompilerUtil.slotCount). + */ + public static int slotCount(ValType type) { + switch (type.opcode()) { + case ValType.ID.I32: + case ValType.ID.F32: + case ValType.ID.Ref: + case ValType.ID.RefNull: + case ValType.ID.ExnRef: + return 1; + case ValType.ID.I64: + case ValType.ID.F64: + return 2; + default: + throw new IllegalArgumentException("Unsupported type: " + type); + } + } + + /** + * Get local variable type (mirrors CompilerUtil.localType). + */ + public static ValType localType(FunctionType type, FunctionBody body, int localIndex) { + if (localIndex < type.params().size()) { + return type.params().get(localIndex); + } else { + return body.localTypes().get(localIndex - type.params().size()); + } + } + + /** + * Get default value for a ValType as a Java source code string. + * Mirrors CompilerUtil.defaultValue but returns String for source code generation. + */ + public static String defaultValue(ValType type) { + switch (type.opcode()) { + case ValType.ID.I32: + return "0"; + case ValType.ID.I64: + return "0L"; + case ValType.ID.F32: + return "0.0f"; + case ValType.ID.F64: + return "0.0"; + case ValType.ID.Ref: + case ValType.ID.RefNull: + case ValType.ID.ExnRef: + return "0"; // ref null is represented as 0 in int + default: + throw new IllegalArgumentException("Unsupported ValType: " + type); + } + } + + /** + * Get Java type name as string for a ValType. + */ + public static String javaTypeName(ValType type) { + return javaTypeName(jvmType(type)); + } + + /** + * Get Java type name as string for a JVM type. + */ + public static String javaTypeName(Class jvmType) { + if (jvmType == int.class) { + return "int"; + } else if (jvmType == long.class) { + return "long"; + } else if (jvmType == float.class) { + return "float"; + } else if (jvmType == double.class) { + return "double"; + } else if (jvmType == void.class) { + return "void"; + } else { + return jvmType.getName(); + } + } + + /** + * Convert JVM type to JavaParser type. + */ + public static com.github.javaparser.ast.type.Type javaParserType(Class jvmType) { + if (jvmType == int.class) { + return PrimitiveType.intType(); + } else if (jvmType == long.class) { + return PrimitiveType.longType(); + } else if (jvmType == float.class) { + return PrimitiveType.floatType(); + } else if (jvmType == double.class) { + return PrimitiveType.doubleType(); + } else if (jvmType == void.class) { + return StaticJavaParser.parseType("void"); + } else if (jvmType == long[].class) { + return new ArrayType(PrimitiveType.longType()); + } else { + return StaticJavaParser.parseType(jvmType.getName()); + } + } + + /** + * Generate source code to unbox long to JVM type (mirrors CompilerUtil.emitLongToJvm). + */ + public static String unboxLongToJvm(String longExpr, ValType type) { + switch (type.opcode()) { + case ValType.ID.I32: + case ValType.ID.Ref: + case ValType.ID.RefNull: + case ValType.ID.ExnRef: + return "((int) " + longExpr + ")"; + case ValType.ID.I64: + return longExpr; + case ValType.ID.F32: + return "com.dylibso.chicory.wasm.types.Value.longToFloat(" + longExpr + ")"; + case ValType.ID.F64: + return "com.dylibso.chicory.wasm.types.Value.longToDouble(" + longExpr + ")"; + default: + throw new IllegalArgumentException("Unsupported ValType: " + type); + } + } + + /** + * Generate source code to box JVM type to long (mirrors CompilerUtil.emitJvmToLong). + */ + public static String boxJvmToLong(String jvmExpr, ValType type) { + switch (type.opcode()) { + case ValType.ID.I32: + case ValType.ID.Ref: + case ValType.ID.RefNull: + case ValType.ID.ExnRef: + return "((long) " + jvmExpr + ")"; + case ValType.ID.I64: + return jvmExpr; + case ValType.ID.F32: + return "com.dylibso.chicory.wasm.types.Value.floatToLong(" + jvmExpr + ")"; + case ValType.ID.F64: + return "com.dylibso.chicory.wasm.types.Value.doubleToLong(" + jvmExpr + ")"; + default: + throw new IllegalArgumentException("Unsupported ValType: " + type); + } + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/TypeStack.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/TypeStack.java new file mode 100644 index 000000000..3c2459fa4 --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/TypeStack.java @@ -0,0 +1,120 @@ +package com.dylibso.chicory.source.compiler.internal; + +import static com.dylibso.chicory.wasm.types.Instruction.EMPTY_OPERANDS; + +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.Instruction; +import com.dylibso.chicory.wasm.types.OpCode; +import com.dylibso.chicory.wasm.types.ValType; +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.HashMap; +import java.util.Map; + +/** + * Type stack tracking for WasmAnalyzer. Aligned with the ASM compiler's TypeStack behavior. + * + *

Key design: enterScope/exitScope do NOT modify the current type stack. enterScope pre-computes + * a "restore" stack (for use after unreachable code), and exitScope just cleans up bookkeeping. + */ +final class TypeStack { + + public static final Instruction FUNCTION_SCOPE = + new Instruction(-1, OpCode.NOP, EMPTY_OPERANDS); + + private final Deque> types = new ArrayDeque<>(); + private final Deque> restore = new ArrayDeque<>(); + private final Map scopes = new HashMap<>(); + + public TypeStack() { + this.types.push(new ArrayDeque<>()); + } + + public ValType peek() { + return types().getFirst(); + } + + public void push(ValType type) { + types().push(type); + } + + public void pop(ValType expected) { + var actual = types().pop(); + if (!ValType.matches(actual, expected)) { + throw new IllegalArgumentException("Expected type " + expected + " <> " + actual); + } + } + + public void popRef() { + var actual = types().pop(); + if (!actual.equals(ValType.FuncRef) && !actual.equals(ValType.ExternRef)) { + throw new IllegalArgumentException("Expected reference type <> " + actual); + } + } + + public void pushTypes() { + types.push(new ArrayDeque<>(types())); + } + + public void popTypes() { + types.pop(); + } + + /** + * Enter a new scope. Does NOT modify the current type stack. Pre-computes the "restore" stack + * which represents what the type stack should look like after the scope exits (with params + * replaced by returns). This restore stack is used by scopeRestore() after unreachable code. + */ + public void enterScope(Instruction scope, FunctionType scopeType) { + scopes.put(scope, types().size()); + + // Pre-compute the restored stack: copy current, remove params, add returns + Deque stack = new ArrayDeque<>(types()); + for (int i = 0; i < scopeType.params().size(); i++) { + stack.pop(); + } + for (ValType type : scopeType.returns()) { + stack.push(type); + } + restore.push(stack); + } + + /** + * Exit a scope. Does NOT modify the current type stack. Just cleans up scope bookkeeping. + */ + public void exitScope(Instruction scope) { + scopes.remove(scope); + restore.pop(); + } + + /** + * Restore the type stack after unreachable code (e.g., after BR/UNREACHABLE followed by END). + * Replaces the current type stack with the pre-computed restore stack. + */ + public void scopeRestore() { + types.pop(); + types.push(restore.getFirst()); + } + + public int scopeStackSize(Instruction scope) { + Integer size = scopes.get(scope); + if (size == null) { + throw new IllegalStateException("Unknown scope: " + scope); + } + return size; + } + + public Deque types() { + return types.getFirst(); + } + + public Deque typesSnapshot() { + return new ArrayDeque<>(types()); + } + + public void verifyEmpty() { + if (!types().isEmpty()) { + throw new IllegalStateException("Stack not empty: " + types()); + } + } +} diff --git a/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/WasmAnalyzer.java b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/WasmAnalyzer.java new file mode 100644 index 000000000..7bddf58ea --- /dev/null +++ b/source-compiler/src/main/java/com/dylibso/chicory/source/compiler/internal/WasmAnalyzer.java @@ -0,0 +1,1063 @@ +package com.dylibso.chicory.source.compiler.internal; + +import static com.dylibso.chicory.source.compiler.internal.CompilerUtil.localType; +import static com.dylibso.chicory.source.compiler.internal.TypeStack.FUNCTION_SCOPE; +import static java.util.Collections.reverse; +import static java.util.stream.Collectors.toCollection; +import static java.util.stream.Collectors.toUnmodifiableList; + +import com.dylibso.chicory.wasm.ChicoryException; +import com.dylibso.chicory.wasm.WasmModule; +import com.dylibso.chicory.wasm.types.AnnotatedInstruction; +import com.dylibso.chicory.wasm.types.ExternalType; +import com.dylibso.chicory.wasm.types.FunctionBody; +import com.dylibso.chicory.wasm.types.FunctionImport; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.Global; +import com.dylibso.chicory.wasm.types.GlobalImport; +import com.dylibso.chicory.wasm.types.Instruction; +import com.dylibso.chicory.wasm.types.OpCode; +import com.dylibso.chicory.wasm.types.Table; +import com.dylibso.chicory.wasm.types.TableImport; +import com.dylibso.chicory.wasm.types.ValType; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.List; +import java.util.Optional; +import java.util.stream.IntStream; +import java.util.stream.LongStream; +import java.util.stream.Stream; + +final class WasmAnalyzer { + + private final WasmModule module; + private final List globalTypes; + private final List functionTypes; + private final List tableTypes; + private final int functionImports; + + /** Tracks scope nesting for structured control flow emission. */ + static final class ScopeInfo { + final int label; + final OpCode opcode; // BLOCK, LOOP, IF, or NOP (function scope) + final FunctionType blockType; + final Instruction scopeInstruction; + boolean elseEncountered; // tracks whether ELSE was seen for IF scopes + + ScopeInfo(int label, OpCode opcode, FunctionType blockType, Instruction scopeInstruction) { + this.label = label; + this.opcode = opcode; + this.blockType = blockType; + this.scopeInstruction = scopeInstruction; + } + } + + public WasmAnalyzer(WasmModule module) { + this.module = module; + this.globalTypes = getGlobalTypes(module); + this.functionTypes = getFunctionTypes(module); + this.tableTypes = getTableTypes(module); + this.functionImports = module.importSection().count(ExternalType.FUNCTION); + } + + public List globalTypes() { + return globalTypes; + } + + public List functionTypes() { + return functionTypes; + } + + @SuppressWarnings("checkstyle:modifiedcontrolvariable") + public List analyze(int funcId) { + var functionType = functionTypes.get(funcId); + var body = module.codeSection().getFunctionBody(funcId - functionImports); + var stack = new TypeStack(); + int nextLabel = 0; + List result = new ArrayList<>(); + + // Scope stack for structured control flow + Deque scopeStack = new ArrayDeque<>(); + + // Function scope (outermost) + int funcLabel = nextLabel++; + stack.enterScope(FUNCTION_SCOPE, FunctionType.of(List.of(), functionType.returns())); + scopeStack.push(new ScopeInfo(funcLabel, OpCode.NOP, functionType, FUNCTION_SCOPE)); + + int exitBlockDepth = -1; + int exitTargetLabel = -1; + for (int idx = 0; idx < body.instructions().size(); idx++) { + AnnotatedInstruction ins = body.instructions().get(idx); + + // Skip instructions after unconditional control transfer + if (exitBlockDepth >= 0) { + if (ins.depth() > exitBlockDepth + || (ins.opcode() != OpCode.ELSE && ins.opcode() != OpCode.END)) { + continue; + } + + if (ins.opcode() == OpCode.END) { + stack.scopeRestore(); + // Check if we've reached the target scope + if (!scopeStack.isEmpty() && scopeStack.peek().label == exitTargetLabel) { + // Function scope: don't process END, let implicit return handle it + if (scopeStack.peek().opcode == OpCode.NOP) { + continue; + } + exitBlockDepth = -1; + exitTargetLabel = -1; + // Fall through to normal END processing + } else if (!scopeStack.isEmpty() + && scopeStack.peek().opcode == OpCode.IF + && !scopeStack.peek().elseEncountered) { + // IF without ELSE: implicit else path makes code after + // the if reachable, so clear dead code and fall through + // to normal END processing + exitBlockDepth = -1; + exitTargetLabel = -1; + // Fall through to normal END processing + } else if (!scopeStack.isEmpty() + && (scopeStack.peek().opcode == OpCode.BLOCK + || scopeStack.peek().opcode == OpCode.LOOP)) { + // Block/loop scope: dead code inside doesn't make code + // after the scope dead (there may be alternate paths via br_if) + exitBlockDepth = -1; + exitTargetLabel = -1; + // Fall through to normal END processing + } else { + // Intermediate scope: pop and emit SCOPE_EXIT, stay in dead code + ScopeInfo scope = scopeStack.pop(); + if (scope.opcode != OpCode.NOP) { + result.add( + new CompilerInstruction( + CompilerOpCode.SCOPE_EXIT, + prependLabel(scope.label, scope.blockType.returns()))); + } + continue; + } + } else { + // ELSE: clear dead code mode, fall through + if (!scopeStack.isEmpty() && scopeStack.peek().opcode == OpCode.IF) { + scopeStack.peek().elseEncountered = true; + } + exitBlockDepth = -1; + exitTargetLabel = -1; + } + } + + switch (ins.opcode()) { + case NOP: + break; + + case UNREACHABLE: + exitBlockDepth = ins.depth(); + exitTargetLabel = scopeStack.peek().label; + result.add(new CompilerInstruction(CompilerOpCode.TRAP)); + break; + + case BLOCK: + { + int label = nextLabel++; + var bt = blockType(ins); + stack.enterScope(ins.scope(), bt); + scopeStack.push(new ScopeInfo(label, OpCode.BLOCK, bt, ins.scope())); + // operands: [label, ...result_type_ids] + result.add( + new CompilerInstruction( + CompilerOpCode.BLOCK_ENTER, + prependLabel(label, bt.returns()))); + break; + } + + case LOOP: + { + int label = nextLabel++; + var bt = blockType(ins); + stack.enterScope(ins.scope(), bt); + scopeStack.push(new ScopeInfo(label, OpCode.LOOP, bt, ins.scope())); + // operands: [label, paramCount, param_type_ids..., return_type_ids...] + long[] operands = new long[2 + bt.params().size() + bt.returns().size()]; + operands[0] = label; + operands[1] = bt.params().size(); + for (int i = 0; i < bt.params().size(); i++) { + operands[2 + i] = bt.params().get(i).id(); + } + for (int i = 0; i < bt.returns().size(); i++) { + operands[2 + bt.params().size() + i] = bt.returns().get(i).id(); + } + result.add(new CompilerInstruction(CompilerOpCode.LOOP_ENTER, operands)); + break; + } + + case IF: + { + stack.pop(ValType.I32); + int label = nextLabel++; + var bt = blockType(ins); + stack.enterScope(ins.scope(), bt); + // Save stack for else branch if ELSE exists + boolean hasElse = + body.instructions().get(ins.labelFalse() - 1).opcode() + == OpCode.ELSE; + if (hasElse) { + stack.pushTypes(); + } + scopeStack.push(new ScopeInfo(label, OpCode.IF, bt, ins.scope())); + // operands: [label, paramCount, param_type_ids..., return_type_ids...] + long[] operands = new long[2 + bt.params().size() + bt.returns().size()]; + operands[0] = label; + operands[1] = bt.params().size(); + for (int i = 0; i < bt.params().size(); i++) { + operands[2 + i] = bt.params().get(i).id(); + } + for (int i = 0; i < bt.returns().size(); i++) { + operands[2 + bt.params().size() + i] = bt.returns().get(i).id(); + } + result.add(new CompilerInstruction(CompilerOpCode.IF_ENTER, operands)); + break; + } + + case ELSE: + if (!scopeStack.isEmpty() && scopeStack.peek().opcode == OpCode.IF) { + scopeStack.peek().elseEncountered = true; + } + stack.popTypes(); + result.add(new CompilerInstruction(CompilerOpCode.ELSE_ENTER)); + break; + + case END: + { + if (scopeStack.isEmpty() || scopeStack.peek().opcode == OpCode.NOP) { + break; + } + ScopeInfo scope = scopeStack.pop(); + stack.exitScope(scope.scopeInstruction); + // Don't emit SCOPE_EXIT for function scope (handled by RETURN) + if (scope.opcode != OpCode.NOP) { + result.add( + new CompilerInstruction( + CompilerOpCode.SCOPE_EXIT, + prependLabel(scope.label, scope.blockType.returns()))); + } + break; + } + + case BR: + { + exitBlockDepth = ins.depth(); + int depth = (int) ins.operand(0); + ScopeInfo target = getScopeAtDepth(scopeStack, depth); + exitTargetLabel = target.label; + + if (target.opcode == OpCode.NOP) { + // BR targeting function scope = RETURN + for (var type : reversed(functionType.returns())) { + stack.pop(type); + } + result.add( + new CompilerInstruction( + CompilerOpCode.RETURN, ids(functionType.returns()))); + } else { + emitUnwind(result, stack, target); + if (target.opcode == OpCode.LOOP) { + result.add( + new CompilerInstruction( + CompilerOpCode.CONTINUE, target.label)); + } else { + result.add( + new CompilerInstruction( + CompilerOpCode.BREAK, target.label)); + } + } + break; + } + + case BR_IF: + { + stack.pop(ValType.I32); + int depth = (int) ins.operand(0); + ScopeInfo target = getScopeAtDepth(scopeStack, depth); + + // Embed unwind data into BREAK_IF/CONTINUE_IF operands + // Simple: [label] + // With unwind: [label, drop, type1, type2, ...] + var unwindOpt = computeUnwind(stack, target); + long[] breakOperands; + if (unwindOpt.isPresent()) { + long[] unwindOps = unwindOpt.get().operands().toArray(); + breakOperands = new long[1 + unwindOps.length]; + breakOperands[0] = target.label; + System.arraycopy(unwindOps, 0, breakOperands, 1, unwindOps.length); + } else { + breakOperands = new long[] {target.label}; + } + + if (target.opcode == OpCode.LOOP) { + result.add( + new CompilerInstruction( + CompilerOpCode.CONTINUE_IF, breakOperands)); + } else { + result.add( + new CompilerInstruction( + CompilerOpCode.BREAK_IF, breakOperands)); + } + break; + } + + case BR_TABLE: + { + exitBlockDepth = ins.depth(); + exitTargetLabel = scopeStack.peek().label; + stack.pop(ValType.I32); + + // Use operands (WASM depths), not labelTable (instruction indices) + int entryCount = ins.operandCount(); + + // Single-entry table: just unconditional branch + if (entryCount == 1) { + int depth0 = (int) ins.operand(0); + ScopeInfo target0 = getScopeAtDepth(scopeStack, depth0); + result.add( + new CompilerInstruction(CompilerOpCode.DROP, ValType.I32.id())); + emitUnwind(result, stack, target0); + if (target0.opcode == OpCode.LOOP) { + result.add( + new CompilerInstruction( + CompilerOpCode.CONTINUE, target0.label)); + } else { + result.add( + new CompilerInstruction( + CompilerOpCode.BREAK, target0.label)); + } + break; + } + + // Multi-entry: resolve depths to labels + // Operands: [label0, isLoop0, label1, isLoop1, ...] + // Last pair is the default target + long[] switchOperands = new long[entryCount * 2]; + for (int i = 0; i < entryCount; i++) { + int depth = (int) ins.operand(i); + ScopeInfo target = getScopeAtDepth(scopeStack, depth); + switchOperands[i * 2] = target.label; + switchOperands[i * 2 + 1] = (target.opcode == OpCode.LOOP) ? 1 : 0; + } + result.add(new CompilerInstruction(CompilerOpCode.SWITCH, switchOperands)); + break; + } + + case RETURN: + exitBlockDepth = ins.depth(); + exitTargetLabel = funcLabel; + for (var type : reversed(functionType.returns())) { + stack.pop(type); + } + result.add( + new CompilerInstruction( + CompilerOpCode.RETURN, ids(functionType.returns()))); + break; + + case RETURN_CALL: + result.add( + new CompilerInstruction( + CompilerOpCode.of(OpCode.CALL), ins.operands())); + updateStack(stack, functionTypes.get((int) ins.operand(0))); + + exitBlockDepth = ins.depth(); + exitTargetLabel = funcLabel; + for (var type : reversed(functionType.returns())) { + stack.pop(type); + } + result.add( + new CompilerInstruction( + CompilerOpCode.RETURN, ids(functionType.returns()))); + break; + + case RETURN_CALL_INDIRECT: + stack.pop(ValType.I32); + updateStack(stack, module.typeSection().getType((int) ins.operand(0))); + result.add( + new CompilerInstruction( + CompilerOpCode.of(OpCode.CALL_INDIRECT), ins.operands())); + + exitBlockDepth = ins.depth(); + exitTargetLabel = funcLabel; + for (var type : reversed(functionType.returns())) { + stack.pop(type); + } + result.add( + new CompilerInstruction( + CompilerOpCode.RETURN, ids(functionType.returns()))); + break; + + case THROW: + result.add( + new CompilerInstruction( + CompilerOpCode.of(OpCode.THROW), ins.operands())); + exitBlockDepth = ins.depth(); + exitTargetLabel = scopeStack.peek().label; + break; + + case THROW_REF: + result.add( + new CompilerInstruction( + CompilerOpCode.of(OpCode.THROW_REF), ins.operands())); + exitBlockDepth = ins.depth(); + exitTargetLabel = scopeStack.peek().label; + break; + + case SELECT: + case SELECT_T: + // [t t I32] -> [t] + stack.pop(ValType.I32); + var selectType = stack.peek(); + stack.pop(selectType); + stack.pop(selectType); + stack.push(selectType); + result.add(new CompilerInstruction(CompilerOpCode.SELECT, selectType.id())); + break; + + case DROP: + // [t] -> [] + var dropType = stack.peek(); + stack.pop(dropType); + result.add(new CompilerInstruction(CompilerOpCode.DROP, dropType.id())); + break; + + case LOCAL_TEE: + // [t] -> [t] + var teeType = stack.peek(); + stack.pop(teeType); + stack.push(teeType); + long[] teeOperands = {ins.operand(0), teeType.id()}; + result.add(new CompilerInstruction(CompilerOpCode.LOCAL_TEE, teeOperands)); + break; + + default: + analyzeSimple(result, stack, ins, functionType, body); + } + } + + // implicit return at end of function (skip if already terminated) + if (exitBlockDepth < 0) { + for (var type : reversed(functionType.returns())) { + stack.pop(type); + } + result.add(new CompilerInstruction(CompilerOpCode.RETURN, ids(functionType.returns()))); + } + + return result; + } + + /** Get the scope at the given depth from the top of the scope stack. */ + private static ScopeInfo getScopeAtDepth(Deque scopeStack, int depth) { + int i = 0; + for (ScopeInfo scope : scopeStack) { + if (i == depth) { + return scope; + } + i++; + } + throw new ChicoryException("BR depth " + depth + " exceeds scope stack size"); + } + + /** Emit DROP_KEEP if needed for a branch to the given target scope. */ + private void emitUnwind(List result, TypeStack stack, ScopeInfo target) { + computeUnwind(stack, target).ifPresent(result::add); + } + + /** Compute DROP_KEEP for a branch to the given target scope. */ + private Optional computeUnwind(TypeStack stack, ScopeInfo target) { + boolean forward = (target.opcode != OpCode.LOOP); + var types = forward ? target.blockType.returns() : target.blockType.params(); + int keep = types.size(); + + int drop = stack.types().size() - stack.scopeStackSize(target.scopeInstruction); + if (forward) { + drop -= types.size(); + } + + if (drop <= 0) { + return Optional.empty(); + } + + var operands = LongStream.builder(); + operands.add(drop); + + List dropKeepTypes = + stack.types().stream().limit(drop + keep).collect(toCollection(ArrayList::new)); + reverse(dropKeepTypes); + dropKeepTypes.stream().mapToLong(ValType::id).forEach(operands::add); + + return Optional.of( + new CompilerInstruction(CompilerOpCode.DROP_KEEP, operands.build().toArray())); + } + + private static long[] prependLabel(int label, List types) { + long[] operands = new long[1 + types.size()]; + operands[0] = label; + for (int i = 0; i < types.size(); i++) { + operands[i + 1] = types.get(i).id(); + } + return operands; + } + + private void analyzeSimple( + List out, + TypeStack stack, + Instruction ins, + FunctionType functionType, + FunctionBody body) { + switch (ins.opcode()) { + case I32_CLZ: + case I32_CTZ: + case I32_EQZ: + case I32_EXTEND_16_S: + case I32_EXTEND_8_S: + case I32_LOAD16_S: + case I32_LOAD16_U: + case I32_LOAD8_S: + case I32_LOAD8_U: + case I32_LOAD: + case I32_POPCNT: + case MEMORY_GROW: + case I32_ATOMIC_LOAD: + case I32_ATOMIC_LOAD8_U: + case I32_ATOMIC_LOAD16_U: + // [I32] -> [I32] + stack.pop(ValType.I32); + stack.push(ValType.I32); + break; + case F32_CONVERT_I32_S: + case F32_CONVERT_I32_U: + case F32_LOAD: + case F32_REINTERPRET_I32: + // [I32] -> [F32] + stack.pop(ValType.I32); + stack.push(ValType.F32); + break; + case F32_ABS: + case F32_CEIL: + case F32_FLOOR: + case F32_NEAREST: + case F32_NEG: + case F32_SQRT: + case F32_TRUNC: + // [F32] -> [F32] + stack.pop(ValType.F32); + stack.push(ValType.F32); + break; + case I32_REINTERPRET_F32: + case I32_TRUNC_F32_S: + case I32_TRUNC_F32_U: + case I32_TRUNC_SAT_F32_S: + case I32_TRUNC_SAT_F32_U: + // [F32] -> [I32] + stack.pop(ValType.F32); + stack.push(ValType.I32); + break; + case I32_WRAP_I64: + case I64_EQZ: + // [I64] -> [I32] + stack.pop(ValType.I64); + stack.push(ValType.I32); + break; + case F32_CONVERT_I64_S: + case F32_CONVERT_I64_U: + // [I64] -> [F32] + stack.pop(ValType.I64); + stack.push(ValType.F32); + break; + case F32_DEMOTE_F64: + // [F64] -> [F32] + stack.pop(ValType.F64); + stack.push(ValType.F32); + break; + case I32_TRUNC_F64_S: + case I32_TRUNC_F64_U: + case I32_TRUNC_SAT_F64_S: + case I32_TRUNC_SAT_F64_U: + // [F64] -> [I32] + stack.pop(ValType.F64); + stack.push(ValType.I32); + break; + case I32_ADD: + case I32_AND: + case I32_DIV_S: + case I32_DIV_U: + case I32_EQ: + case I32_GE_S: + case I32_GE_U: + case I32_GT_S: + case I32_GT_U: + case I32_LE_S: + case I32_LE_U: + case I32_LT_S: + case I32_LT_U: + case I32_MUL: + case I32_NE: + case I32_OR: + case I32_REM_S: + case I32_REM_U: + case I32_ROTL: + case I32_ROTR: + case I32_SHL: + case I32_SHR_S: + case I32_SHR_U: + case I32_SUB: + case I32_XOR: + case I32_ATOMIC_RMW_ADD: + case I32_ATOMIC_RMW_SUB: + case I32_ATOMIC_RMW_AND: + case I32_ATOMIC_RMW_OR: + case I32_ATOMIC_RMW_XOR: + case I32_ATOMIC_RMW_XCHG: + case MEM_ATOMIC_NOTIFY: + case I32_ATOMIC_RMW8_ADD_U: + case I32_ATOMIC_RMW8_SUB_U: + case I32_ATOMIC_RMW8_AND_U: + case I32_ATOMIC_RMW8_OR_U: + case I32_ATOMIC_RMW8_XOR_U: + case I32_ATOMIC_RMW8_XCHG_U: + case I32_ATOMIC_RMW16_ADD_U: + case I32_ATOMIC_RMW16_SUB_U: + case I32_ATOMIC_RMW16_AND_U: + case I32_ATOMIC_RMW16_OR_U: + case I32_ATOMIC_RMW16_XOR_U: + case I32_ATOMIC_RMW16_XCHG_U: + // [I32 I32] -> [I32] + stack.pop(ValType.I32); + stack.pop(ValType.I32); + stack.push(ValType.I32); + break; + case I64_EQ: + case I64_GE_S: + case I64_GE_U: + case I64_GT_S: + case I64_GT_U: + case I64_LE_S: + case I64_LE_U: + case I64_LT_S: + case I64_LT_U: + case I64_NE: + // [I64 I64] -> [I32] + stack.pop(ValType.I64); + stack.pop(ValType.I64); + stack.push(ValType.I32); + break; + case F32_ADD: + case F32_COPYSIGN: + case F32_DIV: + case F32_MAX: + case F32_MIN: + case F32_MUL: + case F32_SUB: + // [F32 F32] -> [F32] + stack.pop(ValType.F32); + stack.pop(ValType.F32); + stack.push(ValType.F32); + break; + case F32_EQ: + case F32_GE: + case F32_GT: + case F32_LE: + case F32_LT: + case F32_NE: + // [F32 F32] -> [I32] + stack.pop(ValType.F32); + stack.pop(ValType.F32); + stack.push(ValType.I32); + break; + case F64_EQ: + case F64_GE: + case F64_GT: + case F64_LE: + case F64_LT: + case F64_NE: + // [F64 F64] -> [I32] + stack.pop(ValType.F64); + stack.pop(ValType.F64); + stack.push(ValType.I32); + break; + case I64_CLZ: + case I64_CTZ: + case I64_EXTEND_16_S: + case I64_EXTEND_32_S: + case I64_EXTEND_8_S: + case I64_POPCNT: + // [I64] -> [I64] + stack.pop(ValType.I64); + stack.push(ValType.I64); + break; + case I64_REINTERPRET_F64: + case I64_TRUNC_F64_S: + case I64_TRUNC_F64_U: + case I64_TRUNC_SAT_F64_S: + case I64_TRUNC_SAT_F64_U: + // [F64] -> [I64] + stack.pop(ValType.F64); + stack.push(ValType.I64); + break; + case F64_TRUNC: + case F64_SQRT: + case F64_NEAREST: + case F64_ABS: + case F64_CEIL: + case F64_FLOOR: + case F64_NEG: + // [F64] -> [F64] + stack.pop(ValType.F64); + stack.push(ValType.F64); + break; + case F64_CONVERT_I64_S: + case F64_CONVERT_I64_U: + case F64_REINTERPRET_I64: + // [I64] -> [F64] + stack.pop(ValType.I64); + stack.push(ValType.F64); + break; + case I64_EXTEND_I32_S: + case I64_EXTEND_I32_U: + case I64_LOAD16_S: + case I64_LOAD16_U: + case I64_LOAD32_S: + case I64_LOAD32_U: + case I64_LOAD8_S: + case I64_LOAD8_U: + case I64_LOAD: + case I64_ATOMIC_LOAD: + case I64_ATOMIC_LOAD8_U: + case I64_ATOMIC_LOAD16_U: + case I64_ATOMIC_LOAD32_U: + // [I32] -> [I64] + stack.pop(ValType.I32); + stack.push(ValType.I64); + break; + case I64_TRUNC_F32_S: + case I64_TRUNC_F32_U: + case I64_TRUNC_SAT_F32_S: + case I64_TRUNC_SAT_F32_U: + // [F32] -> [I64] + stack.pop(ValType.F32); + stack.push(ValType.I64); + break; + case F64_CONVERT_I32_S: + case F64_CONVERT_I32_U: + case F64_LOAD: + // [I32] -> [F64] + stack.pop(ValType.I32); + stack.push(ValType.F64); + break; + case F64_PROMOTE_F32: + // [F32] -> [F64] + stack.pop(ValType.F32); + stack.push(ValType.F64); + break; + case I64_ADD: + case I64_AND: + case I64_DIV_S: + case I64_DIV_U: + case I64_MUL: + case I64_OR: + case I64_REM_S: + case I64_REM_U: + case I64_ROTL: + case I64_ROTR: + case I64_SHL: + case I64_SHR_S: + case I64_SHR_U: + case I64_SUB: + case I64_XOR: + // [I64 I64] -> [I64] + stack.pop(ValType.I64); + stack.pop(ValType.I64); + stack.push(ValType.I64); + break; + case F64_ADD: + case F64_COPYSIGN: + case F64_DIV: + case F64_MAX: + case F64_MIN: + case F64_MUL: + case F64_SUB: + // [F64 F64] -> [F64] + stack.pop(ValType.F64); + stack.pop(ValType.F64); + stack.push(ValType.F64); + break; + case I32_STORE: + case I32_STORE8: + case I32_STORE16: + case I32_ATOMIC_STORE: + case I32_ATOMIC_STORE8: + case I32_ATOMIC_STORE16: + // [I32 I32] -> [] + stack.pop(ValType.I32); + stack.pop(ValType.I32); + break; + case F32_STORE: + // [I32 F32] -> [] + stack.pop(ValType.F32); + stack.pop(ValType.I32); + break; + case I64_STORE: + case I64_STORE8: + case I64_STORE16: + case I64_STORE32: + case I64_ATOMIC_STORE: + case I64_ATOMIC_STORE8: + case I64_ATOMIC_STORE16: + case I64_ATOMIC_STORE32: + // [I32 I64] -> [] + stack.pop(ValType.I64); + stack.pop(ValType.I32); + break; + case F64_STORE: + // [I32 F64] -> [] + stack.pop(ValType.F64); + stack.pop(ValType.I32); + break; + case I32_CONST: + case MEMORY_SIZE: + case TABLE_SIZE: + // [] -> [I32] + stack.push(ValType.I32); + break; + case F32_CONST: + // [] -> [F32] + stack.push(ValType.F32); + break; + case I64_CONST: + // [] -> [I64] + stack.push(ValType.I64); + break; + case F64_CONST: + // [] -> [F64] + stack.push(ValType.F64); + break; + case REF_FUNC: + // [] -> [ref] + stack.push(ValType.FuncRef); + break; + case REF_NULL: + // [] -> [ref] + stack.push( + ValType.builder() + .withOpcode(ValType.ID.RefNull) + .withTypeIdx((int) ins.operand(0)) + .build(module.typeSection()::getType)); + break; + case REF_IS_NULL: + // [ref] -> [I32] + stack.popRef(); + stack.push(ValType.I32); + break; + case MEMORY_COPY: + case MEMORY_FILL: + case MEMORY_INIT: + case TABLE_COPY: + case TABLE_INIT: + // [I32 I32 I32] -> [] + stack.pop(ValType.I32); + stack.pop(ValType.I32); + stack.pop(ValType.I32); + break; + case TABLE_FILL: + // [I32 ref I32] -> [] + stack.pop(ValType.I32); + stack.pop(stack.peek()); + stack.pop(ValType.I32); + break; + case TABLE_GET: + // [I32] -> [ref] + stack.pop(ValType.I32); + stack.push(tableTypes.get((int) ins.operand(0))); + break; + case TABLE_GROW: + // [ref I32] -> [I32] + stack.pop(ValType.I32); + stack.pop(tableTypes.get((int) ins.operand(0))); + stack.push(ValType.I32); + break; + case TABLE_SET: + // [I32 ref] -> [] + stack.pop(tableTypes.get((int) ins.operand(0))); + stack.pop(ValType.I32); + break; + case CALL: + // [p*] -> [r*] + updateStack(stack, functionTypes.get((int) ins.operand(0))); + break; + case CALL_INDIRECT: + // [p* I32] -> [r*] + stack.pop(ValType.I32); + updateStack(stack, module.typeSection().getType((int) ins.operand(0))); + break; + case GLOBAL_SET: + case LOCAL_SET: + // [t] -> [] + stack.pop(stack.peek()); + break; + case LOCAL_GET: + // [] -> [t] + stack.push(localType(functionType, body, (int) ins.operand(0))); + break; + case GLOBAL_GET: + // [] -> [t] + stack.push(globalTypes.get((int) ins.operand(0))); + break; + case ATOMIC_FENCE: + case DATA_DROP: + case ELEM_DROP: + // [] -> [] + break; + case I32_ATOMIC_RMW_CMPXCHG: + case I32_ATOMIC_RMW8_CMPXCHG_U: + case I32_ATOMIC_RMW16_CMPXCHG_U: + // [I32 I32 I32] -> [I32] + stack.pop(ValType.I32); + stack.pop(ValType.I32); + stack.pop(ValType.I32); + stack.push(ValType.I32); + break; + case I64_ATOMIC_RMW_ADD: + case I64_ATOMIC_RMW_SUB: + case I64_ATOMIC_RMW_AND: + case I64_ATOMIC_RMW_OR: + case I64_ATOMIC_RMW_XOR: + case I64_ATOMIC_RMW_XCHG: + case I64_ATOMIC_RMW8_ADD_U: + case I64_ATOMIC_RMW8_SUB_U: + case I64_ATOMIC_RMW8_AND_U: + case I64_ATOMIC_RMW8_OR_U: + case I64_ATOMIC_RMW8_XOR_U: + case I64_ATOMIC_RMW8_XCHG_U: + case I64_ATOMIC_RMW16_ADD_U: + case I64_ATOMIC_RMW16_SUB_U: + case I64_ATOMIC_RMW16_AND_U: + case I64_ATOMIC_RMW16_OR_U: + case I64_ATOMIC_RMW16_XOR_U: + case I64_ATOMIC_RMW16_XCHG_U: + case I64_ATOMIC_RMW32_ADD_U: + case I64_ATOMIC_RMW32_SUB_U: + case I64_ATOMIC_RMW32_AND_U: + case I64_ATOMIC_RMW32_OR_U: + case I64_ATOMIC_RMW32_XOR_U: + case I64_ATOMIC_RMW32_XCHG_U: + // [I32 I64] -> [I64] + stack.pop(ValType.I64); + stack.pop(ValType.I32); + stack.push(ValType.I64); + break; + case I64_ATOMIC_RMW_CMPXCHG: + case I64_ATOMIC_RMW8_CMPXCHG_U: + case I64_ATOMIC_RMW16_CMPXCHG_U: + case I64_ATOMIC_RMW32_CMPXCHG_U: + // [I32 I64 I64] -> [I64] + stack.pop(ValType.I64); + stack.pop(ValType.I64); + stack.pop(ValType.I32); + stack.push(ValType.I64); + break; + case MEM_ATOMIC_WAIT32: + // [I32 I32 I64] -> [I32] + stack.pop(ValType.I64); + stack.pop(ValType.I32); + stack.pop(ValType.I32); + stack.push(ValType.I32); + break; + case MEM_ATOMIC_WAIT64: + // [I32 I64 I64] -> [I32] + stack.pop(ValType.I64); + stack.pop(ValType.I64); + stack.pop(ValType.I32); + stack.push(ValType.I32); + break; + default: + throw new ChicoryException("Unhandled opcode: " + ins.opcode()); + } + out.add(new CompilerInstruction(CompilerOpCode.of(ins.opcode()), ins.operands())); + } + + private static void updateStack(TypeStack stack, FunctionType functionType) { + for (ValType type : reversed(functionType.params())) { + stack.pop(type); + } + for (ValType type : functionType.returns()) { + stack.push(type); + } + } + + private FunctionType blockType(Instruction ins) { + var typeId = ins.operand(0); + if (typeId == 0x40) { + return FunctionType.empty(); + } + if (ValType.isValid(typeId)) { + return FunctionType.returning( + ValType.builder().fromId(typeId).build(module.typeSection()::getType)); + } + return module.typeSection().getType((int) typeId); + } + + private static List getGlobalTypes(WasmModule module) { + var importedGlobals = + module.importSection().stream() + .filter(GlobalImport.class::isInstance) + .map(GlobalImport.class::cast) + .map(GlobalImport::type); + + var globals = module.globalSection(); + var moduleGlobals = + IntStream.range(0, globals.globalCount()) + .mapToObj(globals::getGlobal) + .map(Global::valueType); + + return Stream.concat(importedGlobals, moduleGlobals).collect(toUnmodifiableList()); + } + + private static List getFunctionTypes(WasmModule module) { + var importedFunctions = + module.importSection().stream() + .filter(FunctionImport.class::isInstance) + .map(FunctionImport.class::cast) + .map(function -> module.typeSection().getType(function.typeIndex())); + + var functions = module.functionSection(); + var moduleFunctions = + IntStream.range(0, functions.functionCount()) + .mapToObj(i -> functions.getFunctionType(i, module.typeSection())); + + return Stream.concat(importedFunctions, moduleFunctions).collect(toUnmodifiableList()); + } + + private static List getTableTypes(WasmModule module) { + var importedTables = + module.importSection().stream() + .filter(TableImport.class::isInstance) + .map(TableImport.class::cast) + .map(TableImport::entryType); + + var tables = module.tableSection(); + var moduleTables = + IntStream.range(0, tables.tableCount()) + .mapToObj(tables::getTable) + .map(Table::elementType); + + return Stream.concat(importedTables, moduleTables).collect(toUnmodifiableList()); + } + + private static List reversed(List list) { + if (list.size() <= 1) { + return list; + } + List reversed = new ArrayList<>(list); + reverse(reversed); + return reversed; + } + + private static long[] ids(List types) { + return types.stream().mapToLong(ValType::id).toArray(); + } +} diff --git a/source-compiler/src/test/java/com/dylibso/chicory/source/compiler/LocalAliasingTest.java b/source-compiler/src/test/java/com/dylibso/chicory/source/compiler/LocalAliasingTest.java new file mode 100644 index 000000000..82d19c585 --- /dev/null +++ b/source-compiler/src/test/java/com/dylibso/chicory/source/compiler/LocalAliasingTest.java @@ -0,0 +1,350 @@ +package com.dylibso.chicory.source.compiler; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + +import com.dylibso.chicory.compiler.MachineFactoryCompiler; +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.wabt.Wat2Wasm; +import com.dylibso.chicory.wasm.Parser; +import com.dylibso.chicory.wasm.WasmModule; +import org.junit.jupiter.api.Test; + +/** + * End-to-end tests for local variable aliasing. + * + *

Each test runs against three backends (interpreter, ASM compiler, source compiler) and asserts + * they all produce the same result. The interpreter is the ground truth; the ASM compiler uses the + * JVM operand stack (no aliasing issues); the source compiler uses symbolic NameExpr references + * that require a snapshot mechanism to avoid aliasing bugs. + * + *

These tests are derived from patterns observed in WASI test failures (e.g., + * close_preopen.wasm, environ_get-multiple-variables.wasm). + */ +public class LocalAliasingTest { + + private static WasmModule parseWat(String wat) { + return Parser.parse(Wat2Wasm.parse(wat)); + } + + private static Instance interpreterInstance(WasmModule module) { + return Instance.builder(module).build(); + } + + private static Instance asmInstance(WasmModule module) { + return Instance.builder(module).withMachineFactory(MachineFactoryCompiler::compile).build(); + } + + private static Instance sourceInstance(WasmModule module) { + return Instance.builder(module) + .withMachineFactory( + instance -> + MachineFactorySourceCompiler.builder(instance.module()) + .withClassName("com.dylibso.chicory.gen.AliasingTest") + .withDumpSources(false) + .compile() + .apply(instance)) + .build(); + } + + /** + * Runs the exported "test" function on all three backends and asserts they produce the same + * result. + */ + private static void assertAllBackendsAgree(String wat, long[]... argSets) { + WasmModule module = parseWat(wat); + Instance interp = interpreterInstance(module); + Instance asm = asmInstance(module); + Instance source = sourceInstance(module); + + for (long[] args : argSets) { + long[] interpResult = interp.export("test").apply(args); + long[] asmResult = asm.export("test").apply(args); + long[] sourceResult = source.export("test").apply(args); + + String label = "args=" + java.util.Arrays.toString(args); + assertArrayEquals(interpResult, asmResult, "ASM vs interpreter: " + label); + assertArrayEquals(interpResult, sourceResult, "Source vs interpreter: " + label); + } + } + + /** + * Basic aliasing: local.get pushes old value, local.set overwrites, then the old value is used. + * + * 

+     * local.get 0    ;; push original param (e.g., 10)
+     * local.get 0    ;; push original param again
+     * i32.const 1
+     * i32.shl        ;; param << 1 = 20
+     * local.set 0    ;; overwrite param with 20
+     * ;; stack still has old value 10 (from first local.get)
+     * ;; return old value (should be 10, not 20)
+     *
+ */ + @Test + public void testBasicAliasing() { + assertAllBackendsAgree( + "(module\n" + + " (func (export \"test\") (param i32) (result i32)\n" + + " local.get 0\n" + + " local.get 0\n" + + " i32.const 1\n" + + " i32.shl\n" + + " local.set 0\n" + + " )\n" + + ")\n", + new long[] {10}, + new long[] {42}, + new long[] {0}); + } + + /** + * Aliasing with call arguments: old value of local is passed as a call argument even after the + * local has been modified. + * + *

Pattern from WASI tests: push call args, modify local in between, then call. The first + * pushed arg should use the old value. + */ + @Test + public void testAliasingAcrossCallArgs() { + assertAllBackendsAgree( + "(module\n" + + " (func $helper (param i32 i32) (result i32)\n" + + " local.get 0\n" + + " local.get 1\n" + + " i32.add\n" + + " )\n" + + " (func (export \"test\") (param i32) (result i32)\n" + + " local.get 0\n" + + " local.get 0\n" + + " i32.const 3\n" + + " i32.mul\n" + + " local.tee 0\n" + + " call $helper\n" + + " )\n" + + ")\n", + new long[] {10}, + new long[] {7}, + new long[] {1}); + } + + /** + * Multiple reads of the same local used across a loop, where the local is overwritten each + * iteration. Each iteration loads a byte into a local, uses the old value in a computation, + * then overwrites. + */ + @Test + public void testAliasingInLoop() { + assertAllBackendsAgree( + "(module\n" + + " (memory (export \"mem\") 1)\n" + + " (data (i32.const 0) \"\\01\\02\\03\\04\")\n" + + " (func (export \"test\") (param $count i32) (result i32)\n" + + " (local $i i32)\n" + + " (local $sum i32)\n" + + " (local $val i32)\n" + + " (local.set $i (i32.const 0))\n" + + " (local.set $sum (i32.const 0))\n" + + " (block $done\n" + + " (loop $loop\n" + + " (br_if $done (i32.ge_u (local.get $i) (local.get $count)))\n" + + " (local.set $val (i32.load8_u (local.get $i)))\n" + + " (local.get $val)\n" + + " (local.set $val (i32.xor (local.get $val) (i32.const 255)))\n" + + " (local.set $sum (i32.add (local.get $sum)))\n" + + " (local.set $i (i32.add (local.get $i) (i32.const 1)))\n" + + " (br $loop)\n" + + " )\n" + + " )\n" + + " (local.get $sum)\n" + + " )\n" + + ")\n", + new long[] {4}, + new long[] {1}, + new long[] {2}); + } + + /** + * Two locals aliased simultaneously: local.get A, local.get B, then set both, use old values. + * Implements a swap pattern. + */ + @Test + public void testSwapPattern() { + assertAllBackendsAgree( + "(module\n" + + " (func (export \"test\") (param $a i32) (param $b i32) (result i32)\n" + + " local.get $b\n" + + " local.get $a\n" + + " local.set $b\n" + + " local.set $a\n" + + " local.get $a\n" + + " i32.const 1000\n" + + " i32.mul\n" + + " local.get $b\n" + + " i32.add\n" + + " )\n" + + ")\n", + new long[] {3, 7}, + new long[] {100, 200}); + } + + /** + * Aliasing with select instruction: old value of local used in select after local.set. + */ + @Test + public void testAliasingWithSelect() { + assertAllBackendsAgree( + "(module\n" + + " (func (export \"test\") (param $x i32) (result i32)\n" + + " local.get $x\n" + + " local.get $x\n" + + " i32.const 100\n" + + " i32.add\n" + + " local.tee $x\n" + + " local.get $x\n" + + " i32.const 150\n" + + " i32.gt_u\n" + + " select\n" + + " )\n" + + ")\n", + new long[] {10}, + new long[] {60}, + new long[] {50}); + } + + /** + * Aliasing with local.tee: tee sets and pushes, but previously pushed value should be old. + */ + @Test + public void testAliasingWithTee() { + assertAllBackendsAgree( + "(module\n" + + " (func (export \"test\") (param $a i32) (param $b i32) (result i32)\n" + + " local.get $a\n" + + " local.get $a\n" + + " local.get $b\n" + + " i32.add\n" + + " local.tee $a\n" + + " i32.add\n" + + " )\n" + + ")\n", + new long[] {10, 5}, + new long[] {3, 4}, + new long[] {0, 0}); + } + + /** + * Chain of aliased sets: multiple local.set to the same variable in sequence, with old values + * still on the stack. + */ + @Test + public void testChainedAliasing() { + assertAllBackendsAgree( + "(module\n" + + " (func (export \"test\") (param $x i32) (result i32)\n" + + " local.get $x\n" + + " (local.set $x (i32.add (local.get $x) (i32.const 1)))\n" + + " local.get $x\n" + + " (local.set $x (i32.add (local.get $x) (i32.const 1)))\n" + + " local.get $x\n" + + " (local.set $x (i32.add (local.get $x) (i32.const 1)))\n" + + " i32.add\n" + + " i32.add\n" + + " )\n" + + ")\n", + new long[] {10}, + new long[] {0}, + new long[] {100}); + } + + /** + * Aliasing across block boundaries: local.get in outer scope, local.set in inner block, use + * old value after block. + */ + @Test + public void testAliasingAcrossBlocks() { + assertAllBackendsAgree( + "(module\n" + + " (func (export \"test\") (param $x i32) (result i32)\n" + + " local.get $x\n" + + " (block\n" + + " (local.set $x (i32.const 999))\n" + + " )\n" + + " )\n" + + ")\n", + new long[] {42}, + new long[] {7}, + new long[] {0}); + } + + /** + * Aliasing with memory store: push address from local, modify local, store using old address. + * This pattern is common in WASI allocator code (dlmalloc). + */ + @Test + public void testAliasingWithMemoryStore() { + assertAllBackendsAgree( + "(module\n" + + " (memory (export \"mem\") 1)\n" + + " (func (export \"test\") (param $ptr i32) (param $val i32) (result" + + " i32)\n" + + " local.get $ptr\n" + + " (local.set $ptr (i32.add (local.get $ptr) (i32.const 100)))\n" + + " local.get $val\n" + + " i32.store\n" + + " local.get $ptr\n" + + " (i32.add (local.get $val) (i32.const 1))\n" + + " i32.store\n" + + " (i32.load (local.get $ptr))\n" + + " (i32.load (i32.sub (local.get $ptr) (i32.const 100)))\n" + + " i32.add\n" + + " )\n" + + ")\n", + new long[] {0, 42}); + } + + /** + * Aliasing inside an if-else: local.get in outer scope, local.set inside conditional branch, + * use old value after the if-else completes. + */ + @Test + public void testAliasingInsideIfElse() { + assertAllBackendsAgree( + "(module\n" + + " (func (export \"test\") (param $x i32) (param $flag i32) (result" + + " i32)\n" + + " local.get $x\n" + + " (if (local.get $flag)\n" + + " (then (local.set $x (i32.const 777)))\n" + + " (else (local.set $x (i32.const 888)))\n" + + " )\n" + + " )\n" + + ")\n", + new long[] {42, 1}, + new long[] {42, 0}, + new long[] {99, 1}); + } + + /** + * Deeply nested aliasing: value pushed at outer level, modified in multiple nested blocks. + * This pattern triggers multiple scope boundaries. + */ + @Test + public void testDeeplyNestedAliasing() { + assertAllBackendsAgree( + "(module\n" + + " (func (export \"test\") (param $x i32) (result i32)\n" + + " local.get $x\n" + + " (block $b1\n" + + " (block $b2\n" + + " (block $b3\n" + + " (local.set $x (i32.add (local.get $x) (i32.const 1000)))\n" + + " )\n" + + " )\n" + + " )\n" + + " )\n" + + ")\n", + new long[] {5}, + new long[] {0}, + new long[] {999}); + } +} diff --git a/source-compiler/src/test/java/com/dylibso/chicory/source/compiler/SourceCompilerTest.java b/source-compiler/src/test/java/com/dylibso/chicory/source/compiler/SourceCompilerTest.java new file mode 100644 index 000000000..e087f6853 --- /dev/null +++ b/source-compiler/src/test/java/com/dylibso/chicory/source/compiler/SourceCompilerTest.java @@ -0,0 +1,97 @@ +package com.dylibso.chicory.source.compiler; + +import com.dylibso.chicory.corpus.CorpusResources; +import com.dylibso.chicory.source.compiler.internal.Compiler; +import com.dylibso.chicory.source.compiler.internal.CompilerResult; +import com.dylibso.chicory.wabt.Wat2Wasm; +import com.dylibso.chicory.wasm.Parser; +import com.dylibso.chicory.wasm.WasmModule; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import org.junit.jupiter.api.Test; + +public class SourceCompilerTest { + + @Test + public void compilesSimpleAddModuleToJavaSource() throws Exception { + WasmModule module = loadWat("/wat/add.wat"); + + // Compile to Java sources using the new source compiler + Compiler compiler = + Compiler.builder(module) + .withClassName("com.dylibso.chicory.testgen.AddMachine") + .build(); + + // Compile and print to stdout (simple test) + compiler.compile(); + } + + @Test + public void compilesWat2WasmAndDumpsSource() throws Exception { + Path wasmPath = Path.of("../wabt/src/main/resources/wat2wasm"); + if (!Files.exists(wasmPath)) { + System.out.println("wat2wasm binary not found at " + wasmPath + ", skipping"); + return; + } + + byte[] wasmBytes = Files.readAllBytes(wasmPath); + WasmModule module = Parser.parse(wasmBytes); + System.out.println( + "Parsed wat2wasm: " + module.codeSection().functionBodies().length + " functions"); + + Compiler compiler = + Compiler.builder(module) + .withClassName("com.dylibso.chicory.gen.Wat2WasmMachine") + .build(); + + CompilerResult result = compiler.compile(); + + // Dump generated source to target/source-dump/wat2wasm/ + Path dumpDir = Path.of("target/source-dump/wat2wasm"); + Files.createDirectories(dumpDir); + for (var entry : result.collector().sourceFiles().entrySet()) { + String fileName = entry.getKey().replace('.', '/') + ".java"; + Path outFile = dumpDir.resolve(fileName); + Files.createDirectories(outFile.getParent()); + Files.writeString(outFile, entry.getValue()); + System.out.println("Dumped " + outFile + " (" + entry.getValue().length() + " chars)"); + } + } + + @Test + public void dumpWasiTestSource() throws Exception { + Path wasmPath = + Path.of("../wasi-testsuite/tests/rust/testsuite/wasm32-wasip1/close_preopen.wasm"); + if (!Files.exists(wasmPath)) { + System.out.println("WASI test wasm not found at " + wasmPath + ", skipping"); + return; + } + byte[] wasmBytes = Files.readAllBytes(wasmPath); + WasmModule module = Parser.parse(wasmBytes); + + Compiler compiler = + Compiler.builder(module) + .withClassName("com.dylibso.chicory.gen.WasiTestMachine") + .build(); + + CompilerResult result = compiler.compile(); + + Path dumpDir = Path.of("target/source-dump/wasi-diag"); + Files.createDirectories(dumpDir); + for (var entry : result.collector().sourceFiles().entrySet()) { + String fileName = entry.getKey().replace('.', '/') + ".java"; + Path outFile = dumpDir.resolve(fileName); + Files.createDirectories(outFile.getParent()); + Files.writeString(outFile, entry.getValue()); + System.out.println("Dumped " + outFile + " (" + entry.getValue().length() + " chars)"); + } + } + + private static WasmModule loadWat(String classpath) throws IOException { + try (var is = CorpusResources.getResource(classpath.substring(1))) { + byte[] wasm = Wat2Wasm.parse(is); + return Parser.parse(wasm); + } + } +} diff --git a/source-compiler/src/test/java/com/dylibso/chicory/source/compiler/WasmModuleSourceCompilerTest.java b/source-compiler/src/test/java/com/dylibso/chicory/source/compiler/WasmModuleSourceCompilerTest.java new file mode 100644 index 000000000..4daea346f --- /dev/null +++ b/source-compiler/src/test/java/com/dylibso/chicory/source/compiler/WasmModuleSourceCompilerTest.java @@ -0,0 +1,421 @@ +package com.dylibso.chicory.source.compiler; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.dylibso.chicory.corpus.CorpusResources; +import com.dylibso.chicory.runtime.ByteBufferMemory; +import com.dylibso.chicory.runtime.HostFunction; +import com.dylibso.chicory.runtime.ImportMemory; +import com.dylibso.chicory.runtime.ImportValues; +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.runtime.Memory; +import com.dylibso.chicory.runtime.TrapException; +import com.dylibso.chicory.wasm.InvalidException; +import com.dylibso.chicory.wasm.Parser; +import com.dylibso.chicory.wasm.UninstantiableException; +import com.dylibso.chicory.wasm.WasmModule; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.MemoryLimits; +import com.dylibso.chicory.wasm.types.ValType; +import java.util.List; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; +import org.junit.jupiter.api.Test; + +/** + * Ports of runtime/src/test/java/com/dylibso/chicory/runtime/WasmModuleTest.java + * using the source compiler as the machine factory. + */ +public class WasmModuleSourceCompilerTest { + + private static WasmModule loadModule(String fileName) { + return Parser.parse(CorpusResources.getResource(fileName)); + } + + private static Instance buildInstance(WasmModule module) { + return buildInstance(module, ImportValues.builder().build()); + } + + private static Instance buildInstance(WasmModule module, ImportValues imports) { + return Instance.builder(module) + .withImportValues(imports) + .withMachineFactory( + instance -> + MachineFactorySourceCompiler.builder(instance.module()) + .withClassName("com.dylibso.chicory.gen.TestMachine") + .withDumpSources(false) + .compile() + .apply(instance)) + .build(); + } + + @Test + public void shouldWorkFactorial() { + var instance = buildInstance(loadModule("compiled/iterfact.wat.wasm")); + var iterFact = instance.export("iterFact"); + var result = iterFact.apply(5L)[0]; + assertEquals(120L, result); + } + + @Test + public void shouldRunABasicAdd() { + var instance = buildInstance(loadModule("compiled/add.wat.wasm")); + var add = instance.export("add"); + var result = add.apply(5L, 6L)[0]; + assertEquals(11L, result); + } + + @Test + public void shouldSupportBrTable() { + var instance = buildInstance(loadModule("compiled/br_table.wat.wasm")); + var switchLike = instance.export("switch_like"); + assertEquals(102L, switchLike.apply(0L)[0]); + assertEquals(101L, switchLike.apply(1)[0]); + assertEquals(100L, switchLike.apply(2)[0]); + assertEquals(103L, switchLike.apply(-1)[0]); + assertEquals(103L, switchLike.apply(3)[0]); + assertEquals(103L, switchLike.apply(4)[0]); + assertEquals(103L, switchLike.apply(100)[0]); + } + + @Test + public void shouldExerciseBranches() { + var instance = buildInstance(loadModule("compiled/branching.wat.wasm")); + var foo = instance.export("foo"); + assertEquals(42L, foo.apply(0)[0]); + assertEquals(99L, foo.apply(1)[0]); + for (var i = 2; i < 100; i++) { + assertEquals(7L, foo.apply(i)[0]); + } + } + + @Test + public void shouldConsoleLogWithString() { + final AtomicInteger count = new AtomicInteger(); + final String expected = "Hello, World!"; + + var func = + new HostFunction( + "console", + "log", + FunctionType.of(List.of(ValType.I32, ValType.I32), List.of()), + (Instance instance, long... args) -> { + Memory memory = instance.memory(); + int len = (int) args[0]; + int offset = (int) args[1]; + var message = memory.readString(offset, len); + if (expected.equals(message)) { + count.incrementAndGet(); + } + return null; + }); + var instance = + buildInstance( + loadModule("compiled/host-function.wat.wasm"), + ImportValues.builder().addFunction(func).build()); + var logIt = instance.export("logIt"); + logIt.apply(); + assertEquals(10, count.get()); + } + + @Test + public void shouldComputeFactorial() { + var instance = buildInstance(loadModule("compiled/iterfact.wat.wasm")); + var iterFact = instance.export("iterFact"); + for (var i = 0; i < 10; i++) { + var result = iterFact.apply(i)[0]; + assertEquals(factorial(i), result); + } + } + + private static long factorial(int number) { + long result = 1; + for (int factor = 2; factor <= number; factor++) { + result *= factor; + } + return result; + } + + @Test + public void shouldWorkWithStartFunction() { + final AtomicInteger count = new AtomicInteger(); + + var func = + new HostFunction( + "env", + "gotit", + FunctionType.of(List.of(ValType.I32), List.of()), + (Instance instance, long... args) -> { + if (args[0] == 42L) { + count.incrementAndGet(); + } + return null; + }); + buildInstance( + loadModule("compiled/start.wat.wasm"), + ImportValues.builder().addFunction(func).build()); + assertTrue(count.get() > 0); + } + + @Test + public void shouldTrapOnUnreachable() { + var module = loadModule("compiled/trap.wat.wasm"); + var uninstantiable = + assertThrows(UninstantiableException.class, () -> buildInstance(module)); + assertInstanceOf(TrapException.class, uninstantiable.getCause()); + } + + @Test + public void shouldSupportGlobals() { + var instance = buildInstance(loadModule("compiled/globals.wat.wasm")); + var doit = instance.export("doit"); + var result = doit.apply(32)[0]; + assertEquals(42L, result); + } + + @Test + public void shouldCountVowels() { + var instance = buildInstance(loadModule("compiled/count_vowels.rs.wasm")); + var alloc = instance.export("alloc"); + var dealloc = instance.export("dealloc"); + var countVowels = instance.export("count_vowels"); + var memory = instance.memory(); + var message = "Hello, World!"; + var len = message.getBytes(UTF_8).length; + int ptr = (int) alloc.apply(len)[0]; + memory.writeString(ptr, message); + var result = countVowels.apply(ptr, len); + dealloc.apply(ptr, len); + assertEquals(3L, result[0]); + } + + @Test + public void shouldRunBasicCProgram() { + var instance = buildInstance(loadModule("compiled/basic.c.wasm")); + var run = instance.export("run"); + assertEquals(42L, run.apply()[0]); + } + + @Test + public void shouldRunComplexFunction() { + var instance = buildInstance(loadModule("compiled/complex.c.wasm")); + var run = instance.export("run"); + assertEquals(-679, (int) run.apply()[0]); + } + + @Test + public void shouldRunMemoryProgramInC() { + var instance = buildInstance(loadModule("compiled/memory.c.wasm")); + var run = instance.export("run"); + assertEquals(11L, run.apply()[0]); + } + + @Test + public void shouldWorkWithMemoryOps() { + var instance = buildInstance(loadModule("compiled/memory.wat.wasm")); + var run = instance.export("run32"); + assertEquals(42L, run.apply(42)[0]); + assertEquals(Integer.MAX_VALUE, (int) run.apply(Integer.MAX_VALUE)[0]); + assertEquals(Integer.MIN_VALUE, (int) run.apply(Integer.MIN_VALUE)[0]); + + run = instance.export("run64"); + assertEquals(42L, run.apply(42L)[0]); + assertEquals(Long.MIN_VALUE, run.apply(Long.MIN_VALUE)[0]); + assertEquals(Long.MAX_VALUE, run.apply(Long.MAX_VALUE)[0]); + } + + @Test + public void shouldRunKitchenSink() { + var instance = buildInstance(loadModule("compiled/kitchensink.wat.wasm")); + var run = instance.export("run"); + assertEquals(6L, run.apply(100)[0]); + } + + @Test + public void shouldOperateMemoryOps() { + var instance = buildInstance(loadModule("compiled/memories.wat.wasm")); + var run = instance.export("run"); + assertEquals(-25438, (int) run.apply(100)[0]); + } + + @Test + public void shouldRunMixedImports() { + var cbrtFunc = + new HostFunction( + "env", + "cbrt", + FunctionType.of(List.of(ValType.I32), List.of(ValType.F64)), + (Instance instance, long... args) -> { + var x = args[0]; + var cbrt = Math.cbrt((double) x); + return new long[] {Double.doubleToRawLongBits(cbrt)}; + }); + var logResult = new AtomicReference(null); + var logFunc = + new HostFunction( + "env", + "log", + FunctionType.of(List.of(ValType.I32, ValType.F64), List.of()), + (Instance instance, long... args) -> { + var logLevel = args[0]; + var value = (int) Double.longBitsToDouble(args[1]); + logResult.set(logLevel + ": " + value); + return null; + }); + var memory = new ImportMemory("env", "memory", new ByteBufferMemory(new MemoryLimits(1))); + var hostImports = + ImportValues.builder().addFunction(cbrtFunc, logFunc).addMemory(memory).build(); + var instance = buildInstance(loadModule("compiled/mixed-imports.wat.wasm"), hostImports); + var run = instance.export("main"); + run.apply(); + assertEquals("1: 164", logResult.get()); + } + + @Test + public void issue294_BRIF() { + var instance = buildInstance(loadModule("compiled/issue294_brif.wat.wasm")); + assertEquals(5L, instance.export("main").apply(5)[0]); + } + + @Test + public void issue294_BR() { + var instance = buildInstance(loadModule("compiled/issue294_br.wat.wasm")); + assertEquals(4L, instance.export("main").apply()[0]); + } + + @Test + public void issue294_BRTABLE() { + var instance = buildInstance(loadModule("compiled/issue294_brtable.wat.wasm")); + assertEquals(4L, instance.export("main").apply()[0]); + } + + @Test + public void shouldEasilyObtainExportedEntities() { + var instance = buildInstance(loadModule("compiled/exports.wat.wasm")); + assertNotNull(instance.exports().memory("mem").pages()); + assertNotNull(instance.exports().table("tab").size()); + assertNotNull(instance.exports().global("glob1").getValue()); + assertNotNull(instance.exports().function("get-1").apply()); + } + + @Test + public void shouldThrowOnInvalidExports() { + var instance = buildInstance(loadModule("compiled/exports.wat.wasm")); + assertThrows(InvalidException.class, () -> instance.exports().memory("nonexistent")); + assertThrows(InvalidException.class, () -> instance.exports().table("nonexistent")); + assertThrows(InvalidException.class, () -> instance.exports().global("nonexistent")); + assertThrows(InvalidException.class, () -> instance.exports().function("nonexistent")); + assertThrows(InvalidException.class, () -> instance.exports().memory("tab")); + assertThrows(InvalidException.class, () -> instance.exports().table("mem")); + assertThrows(InvalidException.class, () -> instance.exports().global("get-1")); + assertThrows(InvalidException.class, () -> instance.exports().function("glob1")); + } + + @Test + public void shouldImportAliases() { + AtomicBoolean logged1 = new AtomicBoolean(false); + AtomicBoolean logged2 = new AtomicBoolean(false); + var logFn = + new HostFunction( + "env", + "log", + FunctionType.of(List.of(ValType.I32), List.of()), + (inst, args) -> { + logged1.set(true); + return null; + }); + var logWrongSignatureFn = + new HostFunction( + "env", + "log", + FunctionType.of(List.of(ValType.I64), List.of()), + (inst, args) -> { + logged2.set(true); + return null; + }); + var imports = + ImportValues.builder().addFunction(logFn).addFunction(logWrongSignatureFn).build(); + var instance = buildInstance(loadModule("compiled/alias-imports1.wat.wasm"), imports); + instance.exports().function("log").apply(); + instance.exports().function("log-alias").apply(); + assertTrue(logged1.get()); + assertFalse(logged2.get()); + assertEquals(2, instance.imports().functionCount()); + } + + @Test + public void shouldResolveMultipleAliasesByType() { + AtomicBoolean loggedI32 = new AtomicBoolean(false); + AtomicBoolean loggedI64 = new AtomicBoolean(false); + var logI32 = + new HostFunction( + "env", + "log", + FunctionType.of(List.of(ValType.I32), List.of()), + (inst, args) -> { + loggedI32.set(true); + return null; + }); + var logI64 = + new HostFunction( + "env", + "log", + FunctionType.of(List.of(ValType.I64), List.of()), + (inst, args) -> { + loggedI64.set(true); + return null; + }); + var imports = ImportValues.builder().addFunction(logI32).addFunction(logI64).build(); + var instance = buildInstance(loadModule("compiled/alias-imports2.wat.wasm"), imports); + instance.exports().function("log-i32").apply(0); + assertTrue(loggedI32.get()); + assertFalse(loggedI64.get()); + instance.exports().function("log-i64").apply(0); + assertTrue(loggedI32.get()); + assertTrue(loggedI64.get()); + } + + @Test + public void testExternrefHandling() { + var testObject = new Object(); + var sideTable = new java.util.HashMap(); + var imports = + ImportValues.builder() + .addFunction( + new HostFunction( + "env", + "get_host_object", + FunctionType.of(List.of(), List.of(ValType.ExternRef)), + (inst, args) -> { + sideTable.put(123L, testObject); + return new long[] {123L}; + })) + .addFunction( + new HostFunction( + "env", + "is_null", + FunctionType.of( + List.of(ValType.ExternRef), List.of(ValType.I32)), + (inst, args) -> { + long key = args[0]; + return (sideTable.get(key) == null) + ? new long[] {1} + : new long[] {0}; + })) + .build(); + var instance = buildInstance(loadModule("compiled/externref-example.wat.wasm"), imports); + assertEquals(123L, instance.exports().function("process_externref").apply(123L)[0]); + assertEquals(1L, instance.exports().function("is_null").apply(123L)[0]); + var ref = instance.exports().function("get_host_object").apply()[0]; + assertEquals(123L, ref); + assertEquals(0L, instance.exports().function("is_null").apply(123L)[0]); + assertEquals(1L, instance.exports().function("is_null").apply(1L)[0]); + } +} diff --git a/source-compiler/src/test/java/com/dylibso/chicory/testing/ArgsAdapter.java b/source-compiler/src/test/java/com/dylibso/chicory/testing/ArgsAdapter.java new file mode 100644 index 000000000..cfb01e5b5 --- /dev/null +++ b/source-compiler/src/test/java/com/dylibso/chicory/testing/ArgsAdapter.java @@ -0,0 +1,36 @@ +package com.dylibso.chicory.testing; + +import java.util.ArrayDeque; + +public final class ArgsAdapter { + private final ArrayDeque stack; + + private ArgsAdapter() { + stack = new ArrayDeque<>(); + } + + public static ArgsAdapter builder() { + return new ArgsAdapter(); + } + + public long[] build() { + var result = new long[stack.size()]; + int i = stack.size() - 1; + while (!stack.isEmpty()) { + result[i--] = stack.pop(); + } + return result; + } + + public ArgsAdapter add(long[] args) { + for (var arg : args) { + stack.push(arg); + } + return this; + } + + public ArgsAdapter add(long arg) { + stack.push(arg); + return this; + } +} diff --git a/source-compiler/src/test/java/com/dylibso/chicory/testing/Spectest.java b/source-compiler/src/test/java/com/dylibso/chicory/testing/Spectest.java new file mode 100644 index 000000000..9d89548c3 --- /dev/null +++ b/source-compiler/src/test/java/com/dylibso/chicory/testing/Spectest.java @@ -0,0 +1,125 @@ +package com.dylibso.chicory.testing; + +import static com.dylibso.chicory.wasm.types.Value.REF_NULL_VALUE; + +import com.dylibso.chicory.runtime.ByteBufferMemory; +import com.dylibso.chicory.runtime.GlobalInstance; +import com.dylibso.chicory.runtime.HostFunction; +import com.dylibso.chicory.runtime.ImportGlobal; +import com.dylibso.chicory.runtime.ImportMemory; +import com.dylibso.chicory.runtime.ImportTable; +import com.dylibso.chicory.runtime.ImportValues; +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.runtime.TableInstance; +import com.dylibso.chicory.runtime.WasmFunctionHandle; +import com.dylibso.chicory.wasm.types.FunctionType; +import com.dylibso.chicory.wasm.types.MemoryLimits; +import com.dylibso.chicory.wasm.types.Table; +import com.dylibso.chicory.wasm.types.TableLimits; +import com.dylibso.chicory.wasm.types.ValType; +import com.dylibso.chicory.wasm.types.Value; +import java.util.List; + +// https://github.com/WebAssembly/spec/blob/ee82c8e50c5106e0cedada0a083d4cc4129034a2/interpreter/host/spectest.ml +public final class Spectest { + private static final WasmFunctionHandle noop = (Instance instance, long... args) -> null; + + private Spectest() {} + + public static ImportValues toImportValues() { + return ImportValues.builder() + .addFunction(new HostFunction("spectest", "print", FunctionType.empty(), noop)) + .addFunction( + new HostFunction( + "spectest", + "print_i32", + FunctionType.of(List.of(ValType.I32), List.of()), + noop)) + .addFunction( + new HostFunction( + "spectest", + "print_i32_1", + FunctionType.of(List.of(ValType.I32), List.of()), + noop)) + .addFunction( + new HostFunction( + "spectest", + "print_i32_2", + FunctionType.of(List.of(ValType.I32), List.of()), + noop)) + .addFunction( + new HostFunction( + "spectest", + "print_f32", + FunctionType.of(List.of(ValType.F32), List.of()), + noop)) + .addFunction( + new HostFunction( + "spectest", + "print_i32_f32", + FunctionType.of(List.of(ValType.I32, ValType.F32), List.of()), + noop)) + .addFunction( + new HostFunction( + "spectest", + "print_i64", + FunctionType.of(List.of(ValType.I64), List.of()), + noop)) + .addFunction( + new HostFunction( + "spectest", + "print_i64_1", + FunctionType.of(List.of(ValType.I64), List.of()), + noop)) + .addFunction( + new HostFunction( + "spectest", + "print_i64_2", + FunctionType.of(List.of(ValType.I64), List.of()), + noop)) + .addFunction( + new HostFunction( + "spectest", + "print_f64", + FunctionType.of(List.of(ValType.F64), List.of()), + noop)) + .addFunction( + new HostFunction( + "spectest", + "print_f64_f64", + FunctionType.of(List.of(ValType.F64, ValType.F64), List.of()), + noop)) + .addGlobal( + new ImportGlobal( + "spectest", "global_i32", new GlobalInstance(Value.i32(666)))) + .addGlobal( + new ImportGlobal( + "spectest", "global_i64", new GlobalInstance(Value.i64(666)))) + .addGlobal( + new ImportGlobal( + "spectest", + "global_f32", + new GlobalInstance(Value.fromFloat(666.6f)))) + .addGlobal( + new ImportGlobal( + "spectest", + "global_f64", + new GlobalInstance(Value.fromDouble(666.6)))) + .addMemory( + new ImportMemory( + "spectest", "memory", new ByteBufferMemory(new MemoryLimits(1, 2)))) + .addMemory( + new ImportMemory( + "spectest", + "shared_memory", + new ByteBufferMemory(new MemoryLimits(1, 2, true)))) + .addTable( + new ImportTable( + "spectest", + "table", + new TableInstance( + new Table(ValType.FuncRef, new TableLimits(10, 20)), + REF_NULL_VALUE))) + .build(); + } +} diff --git a/source-compiler/src/test/java/com/dylibso/chicory/testing/TestModule.java b/source-compiler/src/test/java/com/dylibso/chicory/testing/TestModule.java new file mode 100644 index 000000000..221d2618f --- /dev/null +++ b/source-compiler/src/test/java/com/dylibso/chicory/testing/TestModule.java @@ -0,0 +1,140 @@ +package com.dylibso.chicory.testing; + +import com.dylibso.chicory.corpus.CorpusResources; +import com.dylibso.chicory.runtime.ImportValues; +import com.dylibso.chicory.runtime.Instance; +import com.dylibso.chicory.runtime.Store; +import com.dylibso.chicory.source.compiler.MachineFactorySourceCompiler; +import com.dylibso.chicory.wabt.Wat2Wasm; +import com.dylibso.chicory.wasm.MalformedException; +import com.dylibso.chicory.wasm.Parser; +import com.dylibso.chicory.wasm.WasmModule; +import java.io.IOException; + +/** + * TestModule for source-compiler tests. Uses MachineFactorySourceCompiler instead of + * MachineFactoryCompiler. + */ +public class TestModule { + + private final WasmModule module; + + /** Fully-qualified mangled class name (package encodes spec, e.g. "com.dylibso.chicory.gen.i32.CompiledMachine_spec_0"). */ + private final String mangledClassName; + + private static final String HACK_MATCH_ALL_MALFORMED_EXCEPTION_TEXT = + "Matching keywords to get the WebAssembly testsuite to pass: " + + "malformed UTF-8 encoding " + + "import after function " + + "inline function type " + + "constant out of range" + + "unknown operator " + + "unexpected token " + + "unexpected mismatching " + + "mismatching label " + + "unknown type " + + "duplicate func " + + "duplicate local " + + "duplicate global " + + "duplicate memory " + + "duplicate table " + + "mismatching label " + + "import after global " + + "import after table " + + "import after memory " + + "i32 constant out of range " + + "unknown label " + + "alignment " + + "multiple start sections"; + + public static TestModule of(String classpath) { + try (var is = CorpusResources.getResource(classpath.substring(1))) { + String mangledClassName = extractMangledClassName(classpath); + + WasmModule module; + if (classpath.endsWith(".wat")) { + byte[] parsed; + try { + parsed = Wat2Wasm.parse(is); + } catch (RuntimeException e) { + throw new MalformedException( + e.getMessage() + HACK_MATCH_ALL_MALFORMED_EXCEPTION_TEXT); + } + module = Parser.parse(parsed); + } else { + module = Parser.parse(is); + } + return new TestModule(module, mangledClassName); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public static TestModule of(WasmModule module) { + return new TestModule(module, null); + } + + /** + * Extract fully-qualified mangled class name from classpath. + * + *

Example: "/i32/spec.0.wasm" -> "com.dylibso.chicory.gen.i32.CompiledMachine_spec_0" + */ + private static String extractMangledClassName(String classpath) { + if (!classpath.startsWith("/") || classpath.length() <= 1) { + return null; + } + + String withoutLeadingSlash = classpath.substring(1); + int firstSlash = withoutLeadingSlash.indexOf('/'); + int lastSlash = withoutLeadingSlash.lastIndexOf('/'); + int lastDot = withoutLeadingSlash.lastIndexOf('.'); + if (firstSlash <= 0 || lastDot <= lastSlash || lastDot <= 0) { + return null; + } + + String moduleDir = withoutLeadingSlash.substring(0, firstSlash); + String filename = withoutLeadingSlash.substring(lastSlash + 1, lastDot); + + String safeModuleDir = moduleDir.replace('-', '_') + "_"; + + String suffix = filename.replace('.', '_').replace('-', '_'); + return "com.dylibso.chicory.gen." + safeModuleDir + ".CompiledMachine_" + suffix; + } + + public TestModule(WasmModule module, String mangledClassName) { + this.module = module; + this.mangledClassName = mangledClassName; + } + + public Instance instantiate(Store s) { + ImportValues importValues = s.toImportValues(); + + // Enable source dumping by default in tests (can be disabled via system property) + // -Dchicory.source.dumpSources=false + boolean dumpSources = !Boolean.getBoolean("chicory.source.dumpSources.disable"); + + // Generate sources BEFORE building instance, so we can dump even if validation fails + if (dumpSources && mangledClassName != null) { + try { + MachineFactorySourceCompiler.builder(module) + .withClassName(mangledClassName) + .withDumpSources(true) + .generateAndDumpSources(); + } catch (Throwable e) { + // Ignore - generateAndDumpSources has its own error handling and finally block + } + } + + return Instance.builder(module) + .withImportValues(importValues) + .withMachineFactory( + instance -> { + return MachineFactorySourceCompiler.builder(instance.module()) + .withClassName(mangledClassName) + .withDumpSources(false) + .compile() + .apply(instance); + }) + .build(); + } +} diff --git a/wabt/src/main/java/com/dylibso/chicory/wabt/Wat2Wasm.java b/wabt/src/main/java/com/dylibso/chicory/wabt/Wat2Wasm.java index c6c0f3558..71eeed5b7 100644 --- a/wabt/src/main/java/com/dylibso/chicory/wabt/Wat2Wasm.java +++ b/wabt/src/main/java/com/dylibso/chicory/wabt/Wat2Wasm.java @@ -1,7 +1,5 @@ package com.dylibso.chicory.wabt; -import static java.nio.file.Files.copy; - import com.dylibso.chicory.log.Logger; import com.dylibso.chicory.log.SystemLogger; import com.dylibso.chicory.runtime.ImportValues; @@ -10,8 +8,6 @@ import com.dylibso.chicory.wasi.WasiOptions; import com.dylibso.chicory.wasi.WasiPreview1; import com.dylibso.chicory.wasm.WasmModule; -import io.roastedroot.zerofs.Configuration; -import io.roastedroot.zerofs.ZeroFs; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; @@ -20,9 +16,6 @@ import java.io.InputStream; import java.io.UncheckedIOException; import java.nio.charset.StandardCharsets; -import java.nio.file.FileSystem; -import java.nio.file.Path; -import java.nio.file.StandardCopyOption; import java.util.List; public final class Wat2Wasm { @@ -51,46 +44,36 @@ public static byte[] parse(String wat) { } } + @SuppressWarnings("UnusedVariable") private static byte[] parse(InputStream is, String fileName) { try (ByteArrayOutputStream stdoutStream = new ByteArrayOutputStream(); ByteArrayOutputStream stderrStream = new ByteArrayOutputStream()) { - - try (FileSystem fs = - ZeroFs.newFileSystem( - Configuration.unix().toBuilder().setAttributeViews("unix").build())) { - - Path target = fs.getPath("tmp"); - java.nio.file.Files.createDirectory(target); - Path path = target.resolve(fileName); - copy(is, path, StandardCopyOption.REPLACE_EXISTING); - - WasiOptions wasiOpts = - WasiOptions.builder() - .withStdout(stdoutStream) - .withStderr(stderrStream) - .withDirectory(target.toString(), target) - .withArguments(List.of("wat2wasm", path.toString(), "--output=-")) - .build(); - - try (var wasi = - WasiPreview1.builder().withLogger(logger).withOptions(wasiOpts).build()) { - ImportValues imports = - ImportValues.builder().addFunction(wasi.toHostFunctions()).build(); - Instance.builder(MODULE) - .withMachineFactory(Wat2WasmModule::create) - .withImportValues(imports) + WasiOptions wasiOpts = + WasiOptions.builder() + .withStdin(is) + .withStdout(stdoutStream) + .withStderr(stderrStream) + .withArguments(List.of("wat2wasm", "-", "--output=-")) .build(); - } catch (WasiExitException e) { - if (e.exitCode() != 0) { - throw new WatParseException( - stdoutStream.toString(StandardCharsets.UTF_8) - + stderrStream.toString(StandardCharsets.UTF_8), - e); - } - } - return stdoutStream.toByteArray(); + try (var wasi = + WasiPreview1.builder().withLogger(logger).withOptions(wasiOpts).build()) { + ImportValues imports = + ImportValues.builder().addFunction(wasi.toHostFunctions()).build(); + Instance.builder(MODULE) + .withMachineFactory(Wat2WasmModule::create) + .withImportValues(imports) + .build(); + } catch (WasiExitException e) { + if (e.exitCode() != 0) { + throw new WatParseException( + stdoutStream.toString(StandardCharsets.UTF_8) + + stderrStream.toString(StandardCharsets.UTF_8), + e); + } } + + return stdoutStream.toByteArray(); } catch (IOException e) { throw new UncheckedIOException(e); } diff --git a/zip-decompiled-wabt.sh b/zip-decompiled-wabt.sh new file mode 100755 index 000000000..75a521d80 --- /dev/null +++ b/zip-decompiled-wabt.sh @@ -0,0 +1,13 @@ +#!/bin/bash +set -e + +cd "$(dirname "$0")" +rm -f decompiled-wabt.zip + +zip -r decompiled-wabt.zip \ + decompiled-wabt/src \ + decompiled-wabt/pom.xml \ + decompiled-wabt/build.sh \ + decompiled-wabt/run.sh \ + decompiled-wabt/Reproducer.md \ + -x '*.class'